home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Developers / src / out-of-phase-102-c / OutOfPhase 1.02 Source / OutOfPhase Folder / PcodeSystem.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-23  |  134.2 KB  |  3,109 lines  |  [TEXT/KAHL]
  1. /* PcodeSystem.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #define SHOW_ME_OPCODEREC  /* we need to see the internals of OpcodeRec */
  31. #define SHOW_ME_STACKELEMENT  /* we also need to be able to see into stack elements */
  32. #include "PcodeSystem.h"
  33. #include "Memory.h"
  34. #include "EventLoop.h"
  35. #include "DataMunging.h"
  36. #include "Alert.h"
  37. #include "FloatingPoint.h"
  38. #include "PcodeStack.h"
  39. #include "PcodeObject.h"
  40. #include "CodeCenter.h"
  41. #include "FunctionCode.h"
  42.  
  43.  
  44. /* number of pcode execution cycles between relinquish CPU calls */
  45. #if DEBUG
  46.     #define WIZZBANGCOUNTINITIALIZER (1024L) /* give us some responsiveness when debugging */
  47. #else
  48.     #define WIZZBANGCOUNTINITIALIZER (65536L)
  49. #endif
  50.  
  51.  
  52. EvalErrors                EvaluatePcode(ParamStackRec* Prep, PcodeRec* Pcode,
  53.                                         CodeCenterRec* CodeCenter, OpcodeRec** OffendingPcode,
  54.                                         long* OffendingInstruction, void* Refcon,
  55.                                         SampleErrors (*GetSampleLeftCopy)(void* Refcon, char* SampleName,
  56.                                             largefixedsigned** SampleData),
  57.                                         SampleErrors (*GetSampleRightCopy)(void* Refcon, char* SampleName,
  58.                                             largefixedsigned** SampleData),
  59.                                         SampleErrors (*GetSampleMiddleCopy)(void* Refcon, char* SampleName,
  60.                                             largefixedsigned** SampleData),
  61.                                         SampleErrors (*GetWaveTableFrameCount)(void* Refcon,
  62.                                             char* WaveTableName, long* FrameCountOut),
  63.                                         SampleErrors (*GetWaveTableTableCount)(void* Refcon,
  64.                                             char* WaveTableName, long* TableCountOut),
  65.                                         SampleErrors (*GetWaveTableCopy)(void* Refcon, char* WaveTableName,
  66.                                             largefixedsigned** WaveTableData))
  67.     {
  68.         /* machine variables */
  69.         StackElement*        Stack;
  70.         long                        StackSize;
  71.         long                        StackPtr;
  72.         long                        ProgramCounter;
  73.         OpcodeRec*            CurrentProcedure;
  74.         long                        Index;
  75.         long                        Scan;
  76.         EvalErrors            ErrorCode;
  77.         long                        WizzBangCount;
  78.         long                        FuncCallDepth;
  79.  
  80.  
  81.         /* check everything out */
  82.         ERROR(OffendingPcode == NIL,PRERR(ForceAbort,
  83.             "EvaluatePcode:  OffendingPcode is NIL"));
  84.         ERROR(OffendingInstruction == NIL,PRERR(ForceAbort,
  85.             "EvaluatePcode:  OffendingInstruction is NIL"));
  86.         CheckPtrExistence(Prep);
  87.         CheckPtrExistence(Pcode);
  88.  
  89.         /* initialize variables */
  90.         Stack = GetStackBase(Prep);
  91.         StackSize = GetStackInitialSize(Prep);
  92.         StackPtr = GetStackNumElements(Prep) - 1;
  93.         ProgramCounter = 0;
  94.         CurrentProcedure = GetOpcodeFromPcode(Pcode);
  95.         FuncCallDepth = 0;
  96.  
  97.         /* main execution loop.  this ends when there is nothing on the stack and */
  98.         /* something tries to execute a return from subroutine, which means the outermost */
  99.         /* procedure is returning.  the final return value of the program will be in P. */
  100.         WizzBangCount = WIZZBANGCOUNTINITIALIZER;
  101.         while (1)
  102.             {
  103.                 WizzBangCount -= 1;
  104.                 if (WizzBangCount == 0)
  105.                     {
  106.                         WizzBangCount = WIZZBANGCOUNTINITIALIZER;
  107.                         if (RelinquishCPUJudiciouslyCheckCancel())
  108.                             {
  109.                                 ErrorCode = eEvalUserCancelled;
  110.                                 goto ExceptionPoint;
  111.                             }
  112.                     }
  113.                 PRNGCHK(CurrentProcedure,&(CurrentProcedure[ProgramCounter].Opcode),
  114.                     sizeof(CurrentProcedure[ProgramCounter].Opcode));
  115.                 switch (CurrentProcedure[ProgramCounter++].Opcode)
  116.                     {
  117.  
  118.                         default:
  119.                             EXECUTE(PRERR(ForceAbort,"EvaluatePcode:  unknown opcode evaluated"));
  120.                             break;
  121.  
  122.                         case epFuncCallUnresolved:
  123.                             /* an unresolved function call.  try to resolve it */
  124.                             /*     -1           0               1           2             3   */
  125.                             /* <opcode> ^"<functionname>" ^[paramlist] <returntype> <reserved> */
  126.                             {
  127.                                 FuncCodeRec*        Function;
  128.                                 DataTypes*            ParameterList;
  129.                                 long                        Limit;
  130.  
  131.                                 /* special note: we can't dispose of what we get from CodeCenter */
  132.                                 /* because it gives us the real thing, not a copy */
  133.                                 PRNGCHK(CurrentProcedure,
  134.                                     &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  135.                                     sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  136.                                 Function = ObtainFunctionHandle(CodeCenter,
  137.                                     &(*(CurrentProcedure[ProgramCounter + 0].ImmediateString)),
  138.                                     StrLen(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  139.                                 if (Function == NIL)
  140.                                     {
  141.                                         ErrorCode = eEvalUndefinedFunction;
  142.                                         goto ExceptionPoint;
  143.                                     }
  144.                                 ParameterList = GetFunctionParameterTypeList(Function);
  145.                                 PRNGCHK(CurrentProcedure,
  146.                                     &(CurrentProcedure[ProgramCounter + 1].DataTypeArray),
  147.                                     sizeof(CurrentProcedure[ProgramCounter + 1].DataTypeArray));
  148.                                 Limit = PtrSize((char*)CurrentProcedure[ProgramCounter
  149.                                     + 1].DataTypeArray);
  150.                                 if (PtrSize((char*)ParameterList) != Limit)
  151.                                     {
  152.                                         /* different number of parameters */
  153.                                         ErrorCode = eEvalWrongNumParametersForFunction;
  154.                                         goto ExceptionPoint;
  155.                                     }
  156.                                 Limit = Limit / sizeof(DataTypes);
  157.                                 for (Index = 0; Index < Limit; Index += 1)
  158.                                     {
  159.                                         if (CurrentProcedure[ProgramCounter + 1].DataTypeArray[Index]
  160.                                             != ParameterList[Index])
  161.                                             {
  162.                                                 /* parameters of different types */
  163.                                                 ErrorCode = eEvalWrongParameterType;
  164.                                                 goto ExceptionPoint;
  165.                                             }
  166.                                     }
  167.                                 PRNGCHK(CurrentProcedure,
  168.                                     &(CurrentProcedure[ProgramCounter + 2].ImmediateInteger),
  169.                                     sizeof(CurrentProcedure[ProgramCounter + 2].ImmediateInteger));
  170.                                 if ((DataTypes)(CurrentProcedure[ProgramCounter + 2].ImmediateInteger)
  171.                                     != GetFunctionReturnType(Function))
  172.                                     {
  173.                                         /* different return types */
  174.                                         ErrorCode = eEvalWrongReturnType;
  175.                                         goto ExceptionPoint;
  176.                                     }
  177.                                 /* finally, the function appears to be the one we want. */
  178.                                 PRNGCHK(CurrentProcedure,
  179.                                     &(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr),
  180.                                     sizeof(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr));
  181.                                 /* first, install the PcodeRec in the instruction */
  182.                                 CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr
  183.                                     = GetOpcodeFromPcode(GetFunctionPcode(Function));
  184.                                 /* next, change the instruction to epFuncCallResolved */
  185.                                 CurrentProcedure[ProgramCounter - 1].Opcode = epFuncCallResolved;
  186.                             }
  187.                             goto epFunctionCallResolvedPoint;
  188.  
  189.                         case epFuncCallResolved:
  190.                          epFunctionCallResolvedPoint:
  191.                             /* a function call whose destination is known. */
  192.                             /*     -1           0               1           2             3    */
  193.                             /* <opcode> ^"<functionname>" ^[paramlist] <returntype> ^<OpcodeRec> */
  194.                             PRNGCHK(CurrentProcedure,
  195.                                 &(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr),
  196.                                 sizeof(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr));
  197.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 3]
  198.                                 .FunctionOpcodeRecPtr);
  199.                             StackPtr += 1;
  200.                             if (StackPtr >= StackSize)
  201.                                 {
  202.                                     StackElement*            NewStack;
  203.  
  204.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  205.                                         * sizeof(StackElement));
  206.                                     if (NewStack == NIL)
  207.                                         {
  208.                                             StackPtr -= 1;
  209.                                             ErrorCode = eEvalOutOfMemory;
  210.                                             goto ExceptionPoint;
  211.                                         }
  212.                                     Stack = NewStack;
  213.                                     StackSize += 8;
  214.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  215.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  216.                                 }
  217.                             /* store return address on stack.  the return address is the address */
  218.                             /* of the NEXT instruction. */
  219.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  220.                             Stack[StackPtr].ElementType = esReturnAddress;
  221.                             Stack[StackPtr].Data.ReturnAddress.Procedure = CurrentProcedure;
  222.                             Stack[StackPtr].Data.ReturnAddress.Index
  223.                                 = ProgramCounter + 4; /* 4 words to skip */
  224.                             /* perform the jump */
  225.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr);
  226.                             CurrentProcedure = CurrentProcedure[ProgramCounter + 3]
  227.                                 .FunctionOpcodeRecPtr;
  228.                             ProgramCounter = 0;
  229.                             /* increment function call depth counter */
  230.                             FuncCallDepth += 1;
  231.                             break;
  232.  
  233.                         case epErrorTrap:
  234.                             /*    -1            0    */
  235.                             /* <opcode> ^"<errorstring>" */
  236.                             PRNGCHK(CurrentProcedure,
  237.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  238.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  239.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  240.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  241.                                 "EvaluatePcode [epErrorTrap]:  expected scalar on stack"));
  242.                             if (Stack[StackPtr].Data.Integer == 0)
  243.                                 {
  244.                                     /* non-recoverable error -- abort */
  245.                                     (void)AskYesNoCancel("Resumable error trap encountered:  _",
  246.                                         CurrentProcedure[ProgramCounter + 0].ImmediateString,
  247.                                         "Abort","Abort",NIL);
  248.                                     ErrorCode = eEvalErrorTrapEncountered;
  249.                                     goto ExceptionPoint;
  250.                                 }
  251.                              else
  252.                                 {
  253.                                     if (AskYesNoCancel("Resumable error trap encountered:  _",
  254.                                         CurrentProcedure[ProgramCounter + 0].ImmediateString,
  255.                                         "Resume","Abort",NIL) != eYes)
  256.                                         {
  257.                                             ErrorCode = eEvalErrorTrapEncountered;
  258.                                             goto ExceptionPoint;
  259.                                         }
  260.                                 }
  261.                             /* leave argument on stack */
  262.                             ProgramCounter += 1;
  263.                             break;
  264.  
  265.                         case epBranchUnconditional:
  266.                             /*    -1            0    */
  267.                             /* <opcode> <branchoffset> */
  268.                             PRNGCHK(CurrentProcedure,
  269.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  270.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  271.                             ProgramCounter = CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  272.                             break;
  273.  
  274.                         case epBranchIfZero:
  275.                             /*    -1            0    */
  276.                             /* <opcode> <branchoffset> */
  277.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  278.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  279.                                 "EvaluatePcode [epBranchIfZero]: bad stack element type"));
  280.                             if (Stack[StackPtr].Data.Integer == 0)
  281.                                 {
  282.                                     PRNGCHK(CurrentProcedure,
  283.                                         &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  284.                                         sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  285.                                     ProgramCounter = CurrentProcedure[ProgramCounter + 0]
  286.                                         .ImmediateInteger;
  287.                                 }
  288.                              else
  289.                                 {
  290.                                     ProgramCounter += 1;
  291.                                 }
  292.                             StackPtr -= 1;
  293.                             break;
  294.  
  295.                         case epBranchIfNotZero:
  296.                             /*    -1            0    */
  297.                             /* <opcode> <branchoffset> */
  298.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  299.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  300.                                 "EvaluatePcode [epBranchIfNotZero]: bad stack element type"));
  301.                             if (Stack[StackPtr].Data.Integer != 0)
  302.                                 {
  303.                                     PRNGCHK(CurrentProcedure,
  304.                                         &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  305.                                         sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  306.                                     ProgramCounter = CurrentProcedure[ProgramCounter + 0]
  307.                                         .ImmediateInteger;
  308.                                 }
  309.                              else
  310.                                 {
  311.                                     ProgramCounter += 1;
  312.                                 }
  313.                             StackPtr -= 1;
  314.                             break;
  315.  
  316.                         case epReturnFromSubroutine:
  317.                             /* - pop return address from top of stack */
  318.                             if (FuncCallDepth == 0)
  319.                                 {
  320.                                     /* if we are returning from root, then it's the end */
  321.                                     goto TotallyDonePoint;
  322.                                 }
  323.                             FuncCallDepth -= 1;
  324.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  325.                             ERROR((Stack[StackPtr].ElementType != esReturnAddress),PRERR(ForceAbort,
  326.                                 "EvaluatePcode [epReturnFromSubroutine]: Stack[0] is not a return address"));
  327.                             ProgramCounter = Stack[StackPtr].Data.ReturnAddress.Index;
  328.                             CheckPtrExistence(Stack[StackPtr].Data.ReturnAddress.Procedure);
  329.                             CurrentProcedure = Stack[StackPtr].Data.ReturnAddress.Procedure;
  330.                             EXECUTE(Stack[StackPtr].ElementType = esScalar;)
  331.                             StackPtr -= 1;
  332.                             break;
  333.  
  334.                         /* arithmetic operations */
  335.                         /* the right hand argument for binary operators is on top of stack */
  336.                         case epOperationFixedEqual:
  337.                         case epOperationIntegerEqual:
  338.                         case epOperationBooleanEqual:
  339.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  340.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  341.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  342.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  343.                                 ,PRERR(ForceAbort,
  344.                                 "EvaluatePcode [epOperationIntegerEqual]: bad stack element type"));
  345.                             Stack[StackPtr - 1].Data.Integer =
  346.                                 Stack[StackPtr - 1].Data.Integer == Stack[StackPtr].Data.Integer;
  347.                             StackPtr -= 1;
  348.                             break;
  349.                         case epOperationFixedNotEqual:
  350.                         case epOperationIntegerNotEqual:
  351.                         case epOperationBooleanNotEqual:
  352.                         case epOperationBooleanXor:
  353.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  354.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  355.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  356.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  357.                                 ,PRERR(ForceAbort,
  358.                                 "EvaluatePcode [epOperationIntegerNotEqual]: bad stack element type"));
  359.                             Stack[StackPtr - 1].Data.Integer =
  360.                                 Stack[StackPtr - 1].Data.Integer != Stack[StackPtr].Data.Integer;
  361.                             StackPtr -= 1;
  362.                             break;
  363.                         case epOperationIntegerXor:
  364.                         case epOperationFixedXor:
  365.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  366.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  367.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  368.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  369.                                 ,PRERR(ForceAbort,
  370.                                 "EvaluatePcode [epOperationIntegerXor]: bad stack element type"));
  371.                             Stack[StackPtr - 1].Data.Integer =
  372.                                 Stack[StackPtr - 1].Data.Integer ^ Stack[StackPtr].Data.Integer;
  373.                             StackPtr -= 1;
  374.                             break;
  375.                         case epOperationBooleanAnd:
  376.                         case epOperationIntegerAnd:
  377.                         case epOperationFixedAnd:
  378.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  379.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  380.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  381.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  382.                                 ,PRERR(ForceAbort,
  383.                                 "EvaluatePcode [epOperationIntegerAnd]: bad stack element type"));
  384.                             Stack[StackPtr - 1].Data.Integer =
  385.                                 Stack[StackPtr - 1].Data.Integer & Stack[StackPtr].Data.Integer;
  386.                                 /* note:  bitwise and! */
  387.                             StackPtr -= 1;
  388.                             break;
  389.                         case epOperationBooleanOr:
  390.                         case epOperationIntegerOr:
  391.                         case epOperationFixedOr:
  392.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  393.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  394.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  395.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  396.                                 ,PRERR(ForceAbort,
  397.                                 "EvaluatePcode [epOperationIntegerOr]: bad stack element type"));
  398.                             Stack[StackPtr - 1].Data.Integer =
  399.                                 Stack[StackPtr - 1].Data.Integer | Stack[StackPtr].Data.Integer;
  400.                                 /* note:  bitwise or! */
  401.                             StackPtr -= 1;
  402.                             break;
  403.                         case epOperationBooleanNot:
  404.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  405.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  406.                                 ,PRERR(ForceAbort,
  407.                                 "EvaluatePcode [epOperationBooleanNot]: bad stack element type"));
  408.                             Stack[StackPtr].Data.Integer = !Stack[StackPtr].Data.Integer;
  409.                             break;
  410.                         case epOperationIntegerNot:
  411.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  412.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  413.                                 ,PRERR(ForceAbort,
  414.                                 "EvaluatePcode [epOperationIntegerNot]: bad stack element type"));
  415.                             Stack[StackPtr].Data.Integer = ~Stack[StackPtr].Data.Integer;
  416.                             break;
  417.                         case epOperationBooleanToInteger:
  418.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  419.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  420.                                 ,PRERR(ForceAbort,
  421.                                 "EvaluatePcode [epOperationBooleanToInteger]: bad stack element type"));
  422.                             break;
  423.                         case epOperationTestFixedNegative:
  424.                         case epOperationTestIntegerNegative:
  425.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  426.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  427.                                 ,PRERR(ForceAbort,
  428.                                 "EvaluatePcode [epOperationTestIntegerNegative]: bad stack element type"));
  429.                             Stack[StackPtr].Data.Integer = (Stack[StackPtr].Data.Integer != 0);
  430.                             break;
  431.                         case epOperationTestFloatNegative:
  432.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  433.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  434.                                 ,PRERR(ForceAbort,
  435.                                 "EvaluatePcode [epOperationTestFloatNegative]: bad stack element type"));
  436.                             Stack[StackPtr].Data.Integer = (Stack[StackPtr].Data.Float != 0);
  437.                             break;
  438.                         case epOperationTestDoubleNegative:
  439.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  440.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  441.                                 ,PRERR(ForceAbort,
  442.                                 "EvaluatePcode [epOperationTestDoubleNegative]: bad stack element type"));
  443.                             Stack[StackPtr].Data.Integer = (Stack[StackPtr].Data.Double != 0);
  444.                             break;
  445.                         case epOperationGetSignFixed:
  446.                         case epOperationGetSignInteger:
  447.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  448.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  449.                                 ,PRERR(ForceAbort,
  450.                                 "EvaluatePcode [epOperationGetSignInteger]: bad stack element type"));
  451.                             if (Stack[StackPtr].Data.Integer < 0)
  452.                                 {
  453.                                     Stack[StackPtr].Data.Integer = -1;
  454.                                 }
  455.                             else if (Stack[StackPtr].Data.Integer > 0)
  456.                                 {
  457.                                     Stack[StackPtr].Data.Integer = 1;
  458.                                 }
  459.                             else
  460.                                 {
  461.                                     Stack[StackPtr].Data.Integer = 0;
  462.                                 }
  463.                             break;
  464.                         case epOperationGetSignFloat:
  465.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  466.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  467.                                 ,PRERR(ForceAbort,
  468.                                 "EvaluatePcode [epOperationGetSignFloat]: bad stack element type"));
  469.                             if (Stack[StackPtr].Data.Float < 0)
  470.                                 {
  471.                                     Stack[StackPtr].Data.Integer = -1;
  472.                                 }
  473.                             else if (Stack[StackPtr].Data.Float > 0)
  474.                                 {
  475.                                     Stack[StackPtr].Data.Integer = 1;
  476.                                 }
  477.                             else
  478.                                 {
  479.                                     Stack[StackPtr].Data.Integer = 0;
  480.                                 }
  481.                             break;
  482.                         case epOperationGetSignDouble:
  483.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  484.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  485.                                 ,PRERR(ForceAbort,
  486.                                 "EvaluatePcode [epOperationGetSignFloat]: bad stack element type"));
  487.                             if (Stack[StackPtr].Data.Double < 0)
  488.                                 {
  489.                                     Stack[StackPtr].Data.Integer = -1;
  490.                                 }
  491.                             else if (Stack[StackPtr].Data.Double > 0)
  492.                                 {
  493.                                     Stack[StackPtr].Data.Integer = 1;
  494.                                 }
  495.                             else
  496.                                 {
  497.                                     Stack[StackPtr].Data.Integer = 0;
  498.                                 }
  499.                             break;
  500.                         case epOperationIntegerToFloat:
  501.                         case epOperationBooleanToFloat:
  502.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  503.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  504.                                 ,PRERR(ForceAbort,
  505.                                 "EvaluatePcode [epOperationIntegerToFloat]: bad stack element type"));
  506.                             Stack[StackPtr].Data.Float = Stack[StackPtr].Data.Integer;
  507.                             break;
  508.                         case epOperationIntegerToDouble:
  509.                         case epOperationBooleanToDouble:
  510.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  511.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  512.                                 ,PRERR(ForceAbort,
  513.                                 "EvaluatePcode [epOperationIntegerToDouble]: bad stack element type"));
  514.                             Stack[StackPtr].Data.Double = Stack[StackPtr].Data.Integer;
  515.                             break;
  516.                         case epOperationIntegerToFixed:
  517.                         case epOperationBooleanToFixed:
  518.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  519.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  520.                                 ,PRERR(ForceAbort,
  521.                                 "EvaluatePcode [epOperationIntegerToFixed]: bad stack element type"));
  522.                             Stack[StackPtr].Data.Integer = int2largefixed(Stack[StackPtr].Data.Integer);
  523.                             break;
  524.                         case epOperationFixedNegation:
  525.                         case epOperationIntegerNegation:
  526.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  527.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  528.                                 ,PRERR(ForceAbort,
  529.                                 "EvaluatePcode [epOperationIntegerNegation]: bad stack element type"));
  530.                             Stack[StackPtr].Data.Integer = - Stack[StackPtr].Data.Integer;
  531.                             break;
  532.                         case epOperationFixedAdd:
  533.                         case epOperationIntegerAdd:
  534.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  535.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  536.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  537.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  538.                                 ,PRERR(ForceAbort,
  539.                                 "EvaluatePcode [epOperationIntegerAdd]: bad stack element type"));
  540.                             Stack[StackPtr - 1].Data.Integer =
  541.                                 Stack[StackPtr - 1].Data.Integer + Stack[StackPtr].Data.Integer;
  542.                             StackPtr -= 1;
  543.                             break;
  544.                         case epOperationFixedSubtract:
  545.                         case epOperationIntegerSubtract:
  546.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  547.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  548.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  549.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  550.                                 ,PRERR(ForceAbort,
  551.                                 "EvaluatePcode [epOperationIntegerSubtract]: bad stack element type"));
  552.                             Stack[StackPtr - 1].Data.Integer =
  553.                                 Stack[StackPtr - 1].Data.Integer - Stack[StackPtr].Data.Integer;
  554.                             StackPtr -= 1;
  555.                             break;
  556.                         case epOperationIntegerMultiply:
  557.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  558.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  559.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  560.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  561.                                 ,PRERR(ForceAbort,
  562.                                 "EvaluatePcode [epOperationIntegerMultiply]: bad stack element type"));
  563.                             Stack[StackPtr - 1].Data.Integer =
  564.                                 Stack[StackPtr - 1].Data.Integer * Stack[StackPtr].Data.Integer;
  565.                             StackPtr -= 1;
  566.                             break;
  567.                         case epOperationIntegerDivide:
  568.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  569.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  570.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  571.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  572.                                 ,PRERR(ForceAbort,
  573.                                 "EvaluatePcode [epOperationIntegerDivide]: bad stack element type"));
  574.                             if (Stack[StackPtr].Data.Integer == 0)
  575.                                 {
  576.                                     ErrorCode = eEvalDivideByZero;
  577.                                     goto ExceptionPoint;
  578.                                 }
  579.                             Stack[StackPtr - 1].Data.Integer =
  580.                                 Stack[StackPtr - 1].Data.Integer / Stack[StackPtr].Data.Integer;
  581.                             StackPtr -= 1;
  582.                             break;
  583.                         case epOperationIntegerImpreciseDivide:
  584.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  585.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  586.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  587.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  588.                                 ,PRERR(ForceAbort,
  589.                                 "EvaluatePcode [epOperationIntegerImpreciseDivide]: bad stack element type"));
  590.                             if (Stack[StackPtr].Data.Integer == 0)
  591.                                 {
  592.                                     ErrorCode = eEvalDivideByZero;
  593.                                     goto ExceptionPoint;
  594.                                 }
  595.                             Stack[StackPtr - 1].Data.Double = (double)Stack[StackPtr - 1].Data.Integer
  596.                                 / (double)Stack[StackPtr].Data.Integer;
  597.                             StackPtr -= 1;
  598.                             break;
  599.                         case epOperationIntegerModulo:
  600.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  601.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  602.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  603.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  604.                                 ,PRERR(ForceAbort,
  605.                                 "EvaluatePcode [epOperationIntegerModulo]: bad stack element type"));
  606.                             if (Stack[StackPtr].Data.Integer == 0)
  607.                                 {
  608.                                     ErrorCode = eEvalDivideByZero;
  609.                                     goto ExceptionPoint;
  610.                                 }
  611.                             Stack[StackPtr - 1].Data.Integer =
  612.                                 Stack[StackPtr - 1].Data.Integer % Stack[StackPtr].Data.Integer;
  613.                             StackPtr -= 1;
  614.                             break;
  615.                         case epOperationFixedAbs:
  616.                         case epOperationIntegerAbs:
  617.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  618.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  619.                                 ,PRERR(ForceAbort,
  620.                                 "EvaluatePcode [epOperationIntegerAbs]: bad stack element type"));
  621.                             if (Stack[StackPtr].Data.Integer < 0)
  622.                                 {
  623.                                     Stack[StackPtr].Data.Integer = - Stack[StackPtr].Data.Integer;
  624.                                 }
  625.                             break;
  626.                         case epOperationFixedShiftLeft:
  627.                         case epOperationIntegerShiftLeft:
  628.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  629.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  630.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  631.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  632.                                 ,PRERR(ForceAbort,
  633.                                 "EvaluatePcode [epOperationIntegerShiftLeft]: bad stack element type"));
  634.                             Stack[StackPtr - 1].Data.Integer =
  635.                                 Stack[StackPtr - 1].Data.Integer << Stack[StackPtr].Data.Integer;
  636.                             StackPtr -= 1;
  637.                             break;
  638.                         case epOperationFixedShiftRight:
  639.                         case epOperationIntegerShiftRight:
  640.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  641.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  642.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  643.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  644.                                 ,PRERR(ForceAbort,
  645.                                 "EvaluatePcode [epOperationIntegerShiftRight]: bad stack element type"));
  646.                             Stack[StackPtr - 1].Data.Integer =
  647.                                 Stack[StackPtr - 1].Data.Integer / (1L << Stack[StackPtr].Data.Integer);
  648.                             StackPtr -= 1;
  649.                             break;
  650.                         case epOperationFixedGreaterThan:
  651.                         case epOperationIntegerGreaterThan:
  652.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  653.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  654.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  655.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  656.                                 ,PRERR(ForceAbort,
  657.                                 "EvaluatePcode [epOperationIntegerGreaterThan]: bad stack element type"));
  658.                             Stack[StackPtr - 1].Data.Integer =
  659.                                 Stack[StackPtr - 1].Data.Integer > Stack[StackPtr].Data.Integer;
  660.                             StackPtr -= 1;
  661.                             break;
  662.                         case epOperationFixedLessThan:
  663.                         case epOperationIntegerLessThan:
  664.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  665.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  666.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  667.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  668.                                 ,PRERR(ForceAbort,
  669.                                 "EvaluatePcode [epOperationIntegerLessThan]: bad stack element type"));
  670.                             Stack[StackPtr - 1].Data.Integer =
  671.                                 Stack[StackPtr - 1].Data.Integer < Stack[StackPtr].Data.Integer;
  672.                             StackPtr -= 1;
  673.                             break;
  674.                         case epOperationFixedGreaterThanOrEqual:
  675.                         case epOperationIntegerGreaterThanOrEqual:
  676.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  677.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  678.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  679.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  680.                                 ,PRERR(ForceAbort,
  681.                                 "EvaluatePcode [epOperationIntegerGreaterThanOrEqual]: bad stack element type"));
  682.                             Stack[StackPtr - 1].Data.Integer =
  683.                                 Stack[StackPtr - 1].Data.Integer >= Stack[StackPtr].Data.Integer;
  684.                             StackPtr -= 1;
  685.                             break;
  686.                         case epOperationFixedLessThanOrEqual:
  687.                         case epOperationIntegerLessThanOrEqual:
  688.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  689.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  690.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  691.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  692.                                 ,PRERR(ForceAbort,
  693.                                 "EvaluatePcode [epOperationIntegerLessThanOrEqual]: bad stack element type"));
  694.                             Stack[StackPtr - 1].Data.Integer =
  695.                                 Stack[StackPtr - 1].Data.Integer <= Stack[StackPtr].Data.Integer;
  696.                             StackPtr -= 1;
  697.                             break;
  698.                         case epOperationFixedToBoolean:
  699.                         case epOperationIntegerToBoolean:
  700.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  701.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  702.                                 "EvaluatePcode [epOperationIntegerToBoolean]: bad stack element type"));
  703.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Integer != 0;
  704.                             break;
  705.                         case epOperationFloatAdd:
  706.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  707.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  708.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  709.                                 ,PRERR(ForceAbort,
  710.                                 "EvaluatePcode [epOperationFloatAdd]: bad stack element type"));
  711.                             Stack[StackPtr - 1].Data.Float =
  712.                                 Stack[StackPtr - 1].Data.Float + Stack[StackPtr].Data.Float;
  713.                             StackPtr -= 1;
  714.                             break;
  715.                         case epOperationFloatSubtract:
  716.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  717.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  718.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  719.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  720.                                 ,PRERR(ForceAbort,
  721.                                 "EvaluatePcode [epOperationFloatSubtract]: bad stack element type"));
  722.                             Stack[StackPtr - 1].Data.Float =
  723.                                 Stack[StackPtr - 1].Data.Float - Stack[StackPtr].Data.Float;
  724.                             StackPtr -= 1;
  725.                             break;
  726.                         case epOperationFloatNegation:
  727.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  728.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  729.                                 "EvaluatePcode [epOperationFloatNegation]: bad stack element type"));
  730.                             Stack[StackPtr].Data.Float = - Stack[StackPtr].Data.Float;
  731.                             break;
  732.                         case epOperationFloatMultiply:
  733.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  734.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  735.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  736.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  737.                                 ,PRERR(ForceAbort,
  738.                                 "EvaluatePcode [epOperationFloatMultiply]: bad stack element type"));
  739.                             Stack[StackPtr - 1].Data.Float =
  740.                                 Stack[StackPtr - 1].Data.Float * Stack[StackPtr].Data.Float;
  741.                             StackPtr -= 1;
  742.                             break;
  743.                         case epOperationFloatDivide:
  744.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  745.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  746.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  747.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  748.                                 ,PRERR(ForceAbort,
  749.                                 "EvaluatePcode [epOperationFloatDivide]: bad stack element type"));
  750.                             Stack[StackPtr - 1].Data.Float =
  751.                                 Stack[StackPtr - 1].Data.Float / Stack[StackPtr].Data.Float;
  752.                             StackPtr -= 1;
  753.                             break;
  754.                         case epOperationFloatShiftLeft:
  755.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  756.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  757.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  758.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  759.                                 ,PRERR(ForceAbort,
  760.                                 "EvaluatePcode [epOperationFloatShiftLeft]: bad stack element type"));
  761.                             Stack[StackPtr - 1].Data.Float =
  762.                                 Stack[StackPtr - 1].Data.Float * FPOWER(2,Stack[StackPtr].Data.Integer);
  763.                             StackPtr -= 1;
  764.                             break;
  765.                         case epOperationFloatShiftRight:
  766.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  767.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  768.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  769.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  770.                                 ,PRERR(ForceAbort,
  771.                                 "EvaluatePcode [epOperationFloatShiftRight]: bad stack element type"));
  772.                             Stack[StackPtr - 1].Data.Float =
  773.                                 Stack[StackPtr - 1].Data.Float * FPOWER(2,-Stack[StackPtr].Data.Integer);
  774.                             StackPtr -= 1;
  775.                             break;
  776.                         case epOperationFloatGreaterThan:
  777.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  778.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  779.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  780.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  781.                                 ,PRERR(ForceAbort,
  782.                                 "EvaluatePcode [epOperationFloatGreaterThan]: bad stack element type"));
  783.                             Stack[StackPtr - 1].Data.Integer =
  784.                                 Stack[StackPtr - 1].Data.Float > Stack[StackPtr].Data.Float;
  785.                             StackPtr -= 1;
  786.                             break;
  787.                         case epOperationFloatLessThan:
  788.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  789.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  790.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  791.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  792.                                 ,PRERR(ForceAbort,
  793.                                 "EvaluatePcode [epOperationFloatLessThan]: bad stack element type"));
  794.                             Stack[StackPtr - 1].Data.Integer =
  795.                                 Stack[StackPtr - 1].Data.Float < Stack[StackPtr].Data.Float;
  796.                             StackPtr -= 1;
  797.                             break;
  798.                         case epOperationFloatGreaterThanOrEqual:
  799.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  800.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  801.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  802.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  803.                                 ,PRERR(ForceAbort,
  804.                                 "EvaluatePcode [epOperationFloatGreaterThanOrEqual]: bad stack element type"));
  805.                             Stack[StackPtr - 1].Data.Integer =
  806.                                 Stack[StackPtr - 1].Data.Float >= Stack[StackPtr].Data.Float;
  807.                             StackPtr -= 1;
  808.                             break;
  809.                         case epOperationFloatLessThanOrEqual:
  810.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  811.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  812.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  813.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  814.                                 ,PRERR(ForceAbort,
  815.                                 "EvaluatePcode [epOperationFloatLessThanOrEqual]: bad stack element type"));
  816.                             Stack[StackPtr - 1].Data.Integer =
  817.                                 Stack[StackPtr - 1].Data.Float <= Stack[StackPtr].Data.Float;
  818.                             StackPtr -= 1;
  819.                             break;
  820.                         case epOperationFloatEqual:
  821.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  822.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  823.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  824.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  825.                                 ,PRERR(ForceAbort,
  826.                                 "EvaluatePcode [epOperationFloatEqual]: bad stack element type"));
  827.                             Stack[StackPtr - 1].Data.Integer =
  828.                                 Stack[StackPtr - 1].Data.Float == Stack[StackPtr].Data.Float;
  829.                             StackPtr -= 1;
  830.                             break;
  831.                         case epOperationFloatNotEqual:
  832.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  833.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  834.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  835.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  836.                                 ,PRERR(ForceAbort,
  837.                                 "EvaluatePcode [epOperationFloatNotEqual]: bad stack element type"));
  838.                             Stack[StackPtr - 1].Data.Integer =
  839.                                 Stack[StackPtr - 1].Data.Float != Stack[StackPtr].Data.Float;
  840.                             StackPtr -= 1;
  841.                             break;
  842.                         case epOperationFloatAbs:
  843.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  844.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  845.                                 "EvaluatePcode [epOperationFloatAbs]: bad stack element type"));
  846.                             if (Stack[StackPtr].Data.Float < 0)
  847.                                 {
  848.                                     Stack[StackPtr].Data.Float = - Stack[StackPtr].Data.Float;
  849.                                 }
  850.                             break;
  851.                         case epOperationFloatToBoolean:
  852.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  853.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  854.                                 "EvaluatePcode [epOperationFloatToBoolean]: bad stack element type"));
  855.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Float != 0;
  856.                             break;
  857.                         case epOperationFloatToInteger:
  858.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  859.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  860.                                 "EvaluatePcode [epOperationFloatToInteger]: bad stack element type"));
  861.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Float;
  862.                             break;
  863.                         case epOperationFloatToDouble:
  864.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  865.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  866.                                 "EvaluatePcode [epOperationFloatToDouble]: bad stack element type"));
  867.                             Stack[StackPtr].Data.Double = Stack[StackPtr].Data.Float;
  868.                             break;
  869.                         case epOperationFloatToFixed:
  870.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  871.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  872.                                 "EvaluatePcode [epOperationFloatToFixed]: bad stack element type"));
  873.                             Stack[StackPtr].Data.Integer = double2largefixed(Stack[StackPtr].Data.Float);
  874.                             break;
  875.                         case epOperationDoubleAdd:
  876.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  877.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  878.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  879.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  880.                                 ,PRERR(ForceAbort,
  881.                                 "EvaluatePcode [epOperationDoubleAdd]: bad stack element type"));
  882.                             Stack[StackPtr - 1].Data.Double =
  883.                                 Stack[StackPtr - 1].Data.Double + Stack[StackPtr].Data.Double;
  884.                             StackPtr -= 1;
  885.                             break;
  886.                         case epOperationDoubleSubtract:
  887.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  888.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  889.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  890.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  891.                                 ,PRERR(ForceAbort,
  892.                                 "EvaluatePcode [epOperationDoubleSubtract]: bad stack element type"));
  893.                             Stack[StackPtr - 1].Data.Double =
  894.                                 Stack[StackPtr - 1].Data.Double - Stack[StackPtr].Data.Double;
  895.                             StackPtr -= 1;
  896.                             break;
  897.                         case epOperationDoubleNegation:
  898.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  899.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  900.                                 ,PRERR(ForceAbort,
  901.                                 "EvaluatePcode [epOperationDoubleNegation]: bad stack element type"));
  902.                             Stack[StackPtr].Data.Double = - Stack[StackPtr].Data.Double;
  903.                             break;
  904.                         case epOperationDoubleMultiply:
  905.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  906.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  907.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  908.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  909.                                 ,PRERR(ForceAbort,
  910.                                 "EvaluatePcode [epOperationDoubleMultiply]: bad stack element type"));
  911.                             Stack[StackPtr - 1].Data.Double =
  912.                                 Stack[StackPtr - 1].Data.Double * Stack[StackPtr].Data.Double;
  913.                             StackPtr -= 1;
  914.                             break;
  915.                         case epOperationDoubleDivide:
  916.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  917.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  918.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  919.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  920.                                 ,PRERR(ForceAbort,
  921.                                 "EvaluatePcode [epOperationDoubleDivide]: bad stack element type"));
  922.                             Stack[StackPtr - 1].Data.Double =
  923.                                 Stack[StackPtr - 1].Data.Double / Stack[StackPtr].Data.Double;
  924.                             StackPtr -= 1;
  925.                             break;
  926.                         case epOperationDoubleShiftLeft:
  927.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  928.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  929.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  930.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  931.                                 ,PRERR(ForceAbort,
  932.                                 "EvaluatePcode [epOperationDoubleShiftLeft]: bad stack element type"));
  933.                             Stack[StackPtr - 1].Data.Double =
  934.                                 Stack[StackPtr - 1].Data.Double * DPOWER(2,Stack[StackPtr].Data.Integer);
  935.                             StackPtr -= 1;
  936.                             break;
  937.                         case epOperationDoubleShiftRight:
  938.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  939.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  940.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  941.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  942.                                 ,PRERR(ForceAbort,
  943.                                 "EvaluatePcode [epOperationDoubleShiftLeft]: bad stack element type"));
  944.                             Stack[StackPtr - 1].Data.Double =
  945.                                 Stack[StackPtr - 1].Data.Double * DPOWER(2,-Stack[StackPtr].Data.Integer);
  946.                             StackPtr -= 1;
  947.                             break;
  948.                         case epOperationDoubleGreaterThan:
  949.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  950.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  951.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  952.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  953.                                 ,PRERR(ForceAbort,
  954.                                 "EvaluatePcode [epOperationDoubleGreaterThan]: bad stack element type"));
  955.                             Stack[StackPtr - 1].Data.Integer =
  956.                                 Stack[StackPtr - 1].Data.Double > Stack[StackPtr].Data.Double;
  957.                             StackPtr -= 1;
  958.                             break;
  959.                         case epOperationDoubleLessThan:
  960.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  961.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  962.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  963.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  964.                                 ,PRERR(ForceAbort,
  965.                                 "EvaluatePcode [epOperationDoubleLessThan]: bad stack element type"));
  966.                             Stack[StackPtr - 1].Data.Integer =
  967.                                 Stack[StackPtr - 1].Data.Double < Stack[StackPtr].Data.Double;
  968.                             StackPtr -= 1;
  969.                             break;
  970.                         case epOperationDoubleGreaterThanOrEqual:
  971.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  972.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  973.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  974.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  975.                                 ,PRERR(ForceAbort,
  976.                                 "EvaluatePcode [epOperationDoubleGreaterThanOrEqual]: bad stack element type"));
  977.                             Stack[StackPtr - 1].Data.Integer =
  978.                                 Stack[StackPtr - 1].Data.Double >= Stack[StackPtr].Data.Double;
  979.                             StackPtr -= 1;
  980.                             break;
  981.                         case epOperationDoubleLessThanOrEqual:
  982.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  983.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  984.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  985.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  986.                                 ,PRERR(ForceAbort,
  987.                                 "EvaluatePcode [epOperationDoubleLessThanOrEqual]: bad stack element type"));
  988.                             Stack[StackPtr - 1].Data.Integer =
  989.                                 Stack[StackPtr - 1].Data.Double <= Stack[StackPtr].Data.Double;
  990.                             StackPtr -= 1;
  991.                             break;
  992.                         case epOperationDoubleEqual:
  993.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  994.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  995.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  996.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  997.                                 ,PRERR(ForceAbort,
  998.                                 "EvaluatePcode [epOperationDoubleEqual]: bad stack element type"));
  999.                             Stack[StackPtr - 1].Data.Integer =
  1000.                                 Stack[StackPtr - 1].Data.Double == Stack[StackPtr].Data.Double;
  1001.                             StackPtr -= 1;
  1002.                             break;
  1003.                         case epOperationDoubleNotEqual:
  1004.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1005.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1006.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  1007.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1008.                                 ,PRERR(ForceAbort,
  1009.                                 "EvaluatePcode [epOperationDoubleNotEqual]: bad stack element type"));
  1010.                             Stack[StackPtr - 1].Data.Integer =
  1011.                                 Stack[StackPtr - 1].Data.Double != Stack[StackPtr].Data.Double;
  1012.                             StackPtr -= 1;
  1013.                             break;
  1014.                         case epOperationDoubleAbs:
  1015.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1016.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1017.                                 "EvaluatePcode [epOperationDoubleAbs]: bad stack element type"));
  1018.                             if (Stack[StackPtr].Data.Double < 0)
  1019.                                 {
  1020.                                     Stack[StackPtr].Data.Double = - Stack[StackPtr].Data.Double;
  1021.                                 }
  1022.                             break;
  1023.                         case epOperationDoubleToBoolean:
  1024.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1025.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1026.                                 "EvaluatePcode [epOperationDoubleToBoolean]: bad stack element type"));
  1027.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Double != 0;
  1028.                             break;
  1029.                         case epOperationDoubleToInteger:
  1030.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1031.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1032.                                 "EvaluatePcode [epOperationDoubleToInteger]: bad stack element type"));
  1033.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Double;
  1034.                             break;
  1035.                         case epOperationDoubleToFloat:
  1036.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1037.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1038.                                 "EvaluatePcode [epOperationDoubleToFloat]: bad stack element type"));
  1039.                             Stack[StackPtr].Data.Float = Stack[StackPtr].Data.Double;
  1040.                             break;
  1041.                         case epOperationDoubleToFixed:
  1042.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1043.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1044.                                 "EvaluatePcode [epOperationDoubleToFixed]: bad stack element type"));
  1045.                             Stack[StackPtr].Data.Integer = double2largefixed(Stack[StackPtr].Data.Double);
  1046.                             break;
  1047.                         case epOperationDoubleSin:
  1048.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1049.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1050.                                 "EvaluatePcode [epOperationDoubleSin]: bad stack element type"));
  1051.                             Stack[StackPtr].Data.Double = DSIN(Stack[StackPtr].Data.Double);
  1052.                             break;
  1053.                         case epOperationDoubleCos:
  1054.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1055.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1056.                                 "EvaluatePcode [epOperationDoubleCos]: bad stack element type"));
  1057.                             Stack[StackPtr].Data.Double = DCOS(Stack[StackPtr].Data.Double);
  1058.                             break;
  1059.                         case epOperationDoubleTan:
  1060.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1061.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1062.                                 "EvaluatePcode [epOperationDoubleTan]: bad stack element type"));
  1063.                             Stack[StackPtr].Data.Double = DTAN(Stack[StackPtr].Data.Double);
  1064.                             break;
  1065.                         case epOperationDoubleAsin:
  1066.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1067.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1068.                                 "EvaluatePcode [epOperationDoubleAsin]: bad stack element type"));
  1069.                             Stack[StackPtr].Data.Double = DASIN(Stack[StackPtr].Data.Double);
  1070.                             break;
  1071.                         case epOperationDoubleAcos:
  1072.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1073.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1074.                                 "EvaluatePcode [epOperationDoubleAcos]: bad stack element type"));
  1075.                             Stack[StackPtr].Data.Double = DACOS(Stack[StackPtr].Data.Double);
  1076.                             break;
  1077.                         case epOperationDoubleAtan:
  1078.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1079.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1080.                                 "EvaluatePcode [epOperationDoubleAtan]: bad stack element type"));
  1081.                             Stack[StackPtr].Data.Double = DATAN(Stack[StackPtr].Data.Double);
  1082.                             break;
  1083.                         case epOperationDoubleLn:
  1084.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1085.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1086.                                 "EvaluatePcode [epOperationDoubleLn]: bad stack element type"));
  1087.                             Stack[StackPtr].Data.Double = DLN(Stack[StackPtr].Data.Double);
  1088.                             break;
  1089.                         case epOperationDoubleExp:
  1090.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1091.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1092.                                 "EvaluatePcode [epOperationDoubleExp]: bad stack element type"));
  1093.                             Stack[StackPtr].Data.Double = DEXP(Stack[StackPtr].Data.Double);
  1094.                             break;
  1095.                         case epOperationDoubleSqrt:
  1096.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1097.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1098.                                 "EvaluatePcode [epOperationDoubleSqrt]: bad stack element type"));
  1099.                             Stack[StackPtr].Data.Double = DSQRT(Stack[StackPtr].Data.Double);
  1100.                             break;
  1101.                         case epOperationDoubleSqr:
  1102.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1103.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1104.                                 "EvaluatePcode [epOperationDoubleSqr]: bad stack element type"));
  1105.                             Stack[StackPtr].Data.Double = Stack[StackPtr].Data.Double
  1106.                                 * Stack[StackPtr].Data.Double;
  1107.                             break;
  1108.                         case epOperationDoublePower:
  1109.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1110.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1111.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  1112.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1113.                                 ,PRERR(ForceAbort,
  1114.                                 "EvaluatePcode [epOperationDoublePower]: bad stack element type"));
  1115.                             Stack[StackPtr - 1].Data.Double =
  1116.                                 DPOWER(Stack[StackPtr - 1].Data.Double,Stack[StackPtr].Data.Double);
  1117.                             StackPtr -= 1;
  1118.                             break;
  1119.                         case epOperationFixedMultiply:
  1120.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1121.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1122.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  1123.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1124.                                 ,PRERR(ForceAbort,
  1125.                                 "EvaluatePcode [epOperationFixedMultiply]: bad stack element type"));
  1126.                             Stack[StackPtr - 1].Data.Integer = largefixedmult(
  1127.                                 Stack[StackPtr - 1].Data.Integer,Stack[StackPtr].Data.Integer);
  1128.                             StackPtr -= 1;
  1129.                             break;
  1130.                         case epOperationFixedDivide:
  1131.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1132.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1133.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  1134.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1135.                                 ,PRERR(ForceAbort,
  1136.                                 "EvaluatePcode [epOperationFixedDivide]: bad stack element type"));
  1137.                             Stack[StackPtr - 1].Data.Integer = double2largefixed(
  1138.                                 largefixed2double(Stack[StackPtr - 1].Data.Integer)
  1139.                                 / largefixed2double(Stack[StackPtr].Data.Integer));
  1140.                             StackPtr -= 1;
  1141.                             break;
  1142.                         case epOperationFixedToInteger:
  1143.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1144.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1145.                                 "EvaluatePcode [epOperationFixedToInteger]: bad stack element type"));
  1146.                             Stack[StackPtr].Data.Integer = largefixed2int(Stack[StackPtr].Data.Integer);
  1147.                             break;
  1148.                         case epOperationFixedToFloat:
  1149.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1150.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1151.                                 "EvaluatePcode [epOperationFixedToFloat]: bad stack element type"));
  1152.                             Stack[StackPtr].Data.Float = largefixed2double(Stack[StackPtr].Data.Integer);
  1153.                             break;
  1154.                         case epOperationFixedToDouble:
  1155.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1156.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1157.                                 "EvaluatePcode [epOperationFixedToDouble]: bad stack element type"));
  1158.                             Stack[StackPtr].Data.Double = largefixed2double(Stack[StackPtr].Data.Integer);
  1159.                             break;
  1160.  
  1161.                         /* other conversion operations */
  1162.                         case epOperationBooleanToIntegerBuried:  /* <opcode> <stackindex> */
  1163.                             /*    -1            0    */
  1164.                             /* <opcode> <branchoffset> */
  1165.                             PRNGCHK(CurrentProcedure,
  1166.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1167.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1168.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1169.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1170.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1171.                                 "EvaluatePcode [epOperationBooleanToIntegerBuried]:  not a scalar"));
  1172.                             ProgramCounter += 1;
  1173.                             break;
  1174.                         case epOperationIntegerToFloatBuried:
  1175.                         case epOperationBooleanToFloatBuried:
  1176.                             /*    -1            0    */
  1177.                             /* <opcode> <branchoffset> */
  1178.                             PRNGCHK(CurrentProcedure,
  1179.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1180.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1181.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1182.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1183.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1184.                                 "EvaluatePcode [epOperationIntegerToFloatBuried]:  not a scalar"));
  1185.                             Stack[Index].Data.Float = Stack[Index].Data.Integer;
  1186.                             ProgramCounter += 1;
  1187.                             break;
  1188.                         case epOperationIntegerToDoubleBuried:
  1189.                         case epOperationBooleanToDoubleBuried:
  1190.                             /*    -1            0    */
  1191.                             /* <opcode> <branchoffset> */
  1192.                             PRNGCHK(CurrentProcedure,
  1193.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1194.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1195.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1196.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1197.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1198.                                 "EvaluatePcode [epOperationIntegerToDoubleBuried]:  not a scalar"));
  1199.                             Stack[Index].Data.Double = Stack[Index].Data.Integer;
  1200.                             ProgramCounter += 1;
  1201.                             break;
  1202.                         case epOperationIntegerToFixedBuried:
  1203.                         case epOperationBooleanToFixedBuried:
  1204.                             /*    -1            0    */
  1205.                             /* <opcode> <branchoffset> */
  1206.                             PRNGCHK(CurrentProcedure,
  1207.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1208.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1209.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1210.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1211.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1212.                                 "EvaluatePcode [epOperationIntegerToFixedBuried]:  not a scalar"));
  1213.                             Stack[Index].Data.Integer = int2largefixed(Stack[Index].Data.Integer);
  1214.                             ProgramCounter += 1;
  1215.                             break;
  1216.                         case epOperationFixedToBooleanBuried:
  1217.                         case epOperationIntegerToBooleanBuried:
  1218.                             /*    -1            0    */
  1219.                             /* <opcode> <branchoffset> */
  1220.                             PRNGCHK(CurrentProcedure,
  1221.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1222.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1223.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1224.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1225.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1226.                                 "EvaluatePcode [epOperationIntegerToBooleanBuried]:  not a scalar"));
  1227.                             Stack[Index].Data.Integer = Stack[Index].Data.Integer != 0;
  1228.                             ProgramCounter += 1;
  1229.                             break;
  1230.                         case epOperationFloatToBooleanBuried:
  1231.                             /*    -1            0    */
  1232.                             /* <opcode> <branchoffset> */
  1233.                             PRNGCHK(CurrentProcedure,
  1234.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1235.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1236.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1237.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1238.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1239.                                 "EvaluatePcode [epOperationFloatToBooleanBuried]:  not a scalar"));
  1240.                             Stack[Index].Data.Integer = Stack[Index].Data.Float != 0;
  1241.                             ProgramCounter += 1;
  1242.                             break;
  1243.                         case epOperationFloatToIntegerBuried:
  1244.                             /*    -1            0    */
  1245.                             /* <opcode> <branchoffset> */
  1246.                             PRNGCHK(CurrentProcedure,
  1247.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1248.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1249.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1250.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1251.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1252.                                 "EvaluatePcode [epOperationFloatToIntegerBuried]:  not a scalar"));
  1253.                             Stack[Index].Data.Integer = Stack[Index].Data.Float;
  1254.                             ProgramCounter += 1;
  1255.                             break;
  1256.                         case epOperationFloatToDoubleBuried:
  1257.                             /*    -1            0    */
  1258.                             /* <opcode> <branchoffset> */
  1259.                             PRNGCHK(CurrentProcedure,
  1260.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1261.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1262.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1263.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1264.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1265.                                 "EvaluatePcode [epOperationFloatToDoubleBuried]:  not a scalar"));
  1266.                             Stack[Index].Data.Double = Stack[Index].Data.Float;
  1267.                             ProgramCounter += 1;
  1268.                             break;
  1269.                         case epOperationFloatToFixedBuried:
  1270.                             /*    -1            0    */
  1271.                             /* <opcode> <branchoffset> */
  1272.                             PRNGCHK(CurrentProcedure,
  1273.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1274.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1275.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1276.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1277.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1278.                                 "EvaluatePcode [epOperationFloatToFixedBuried]:  not a scalar"));
  1279.                             Stack[Index].Data.Integer = double2largefixed(Stack[Index].Data.Float);
  1280.                             ProgramCounter += 1;
  1281.                             break;
  1282.                         case epOperationDoubleToBooleanBuried:
  1283.                             /*    -1            0    */
  1284.                             /* <opcode> <branchoffset> */
  1285.                             PRNGCHK(CurrentProcedure,
  1286.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1287.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1288.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1289.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1290.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1291.                                 "EvaluatePcode [epOperationDoubleToBooleanBuried]:  not a scalar"));
  1292.                             Stack[Index].Data.Integer = Stack[Index].Data.Double != 0;
  1293.                             ProgramCounter += 1;
  1294.                             break;
  1295.                         case epOperationDoubleToIntegerBuried:
  1296.                             /*    -1            0    */
  1297.                             /* <opcode> <branchoffset> */
  1298.                             PRNGCHK(CurrentProcedure,
  1299.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1300.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1301.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1302.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1303.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1304.                                 "EvaluatePcode [epOperationDoubleToIntegerBuried]:  not a scalar"));
  1305.                             Stack[Index].Data.Integer = Stack[Index].Data.Double;
  1306.                             ProgramCounter += 1;
  1307.                             break;
  1308.                         case epOperationDoubleToFloatBuried:
  1309.                             /*    -1            0    */
  1310.                             /* <opcode> <branchoffset> */
  1311.                             PRNGCHK(CurrentProcedure,
  1312.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1313.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1314.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1315.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1316.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1317.                                 "EvaluatePcode [epOperationDoubleToFloatBuried]:  not a scalar"));
  1318.                             Stack[Index].Data.Float = Stack[Index].Data.Double;
  1319.                             ProgramCounter += 1;
  1320.                             break;
  1321.                         case epOperationDoubleToFixedBuried:
  1322.                             /*    -1            0    */
  1323.                             /* <opcode> <branchoffset> */
  1324.                             PRNGCHK(CurrentProcedure,
  1325.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1326.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1327.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1328.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1329.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1330.                                 "EvaluatePcode [epOperationDoubleToFixedBuried]:  not a scalar"));
  1331.                             Stack[Index].Data.Integer = double2largefixed(Stack[Index].Data.Double);
  1332.                             ProgramCounter += 1;
  1333.                             break;
  1334.                         case epOperationFixedToIntegerBuried:
  1335.                             /*    -1            0    */
  1336.                             /* <opcode> <branchoffset> */
  1337.                             PRNGCHK(CurrentProcedure,
  1338.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1339.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1340.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1341.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1342.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1343.                                 "EvaluatePcode [epOperationFixedToIntegerBuried]:  not a scalar"));
  1344.                             Stack[Index].Data.Integer = largefixed2int(Stack[Index].Data.Integer);
  1345.                             ProgramCounter += 1;
  1346.                             break;
  1347.                         case epOperationFixedToFloatBuried:
  1348.                             /*    -1            0    */
  1349.                             /* <opcode> <branchoffset> */
  1350.                             PRNGCHK(CurrentProcedure,
  1351.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1352.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1353.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1354.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1355.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1356.                                 "EvaluatePcode [epOperationFixedToFloatBuried]:  not a scalar"));
  1357.                             Stack[Index].Data.Float = largefixed2double(Stack[Index].Data.Integer);
  1358.                             ProgramCounter += 1;
  1359.                             break;
  1360.                         case epOperationFixedToDoubleBuried:
  1361.                             /*    -1            0    */
  1362.                             /* <opcode> <branchoffset> */
  1363.                             PRNGCHK(CurrentProcedure,
  1364.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1365.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1366.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1367.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1368.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1369.                                 "EvaluatePcode [epOperationFixedToDoubleBuried]:  not a scalar"));
  1370.                             Stack[Index].Data.Double = largefixed2double(Stack[Index].Data.Integer);
  1371.                             ProgramCounter += 1;
  1372.                             break;
  1373.  
  1374.                         /* array sizing stuff. */
  1375.                         case epGetBooleanArraySize:
  1376.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1377.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1378.                                 "EvaluatePcode [epGetBooleanArraySize]: bad stack element type"));
  1379.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  1380.                                 {
  1381.                                     ErrorCode = eEvalArrayDoesntExist;
  1382.                                     goto ExceptionPoint;
  1383.                                 }
  1384.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle);
  1385.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  1386.                             Index = PtrSize((char*)(Stack[StackPtr].Data.ArrayHandle->Array));
  1387.                             DisposeIfNotOnStack(Stack,StackPtr);
  1388.                             Stack[StackPtr].ElementType = esScalar;
  1389.                             Stack[StackPtr].Data.Integer = Index;
  1390.                             break;
  1391.                         case epGetIntegerArraySize:
  1392.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1393.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1394.                                 "EvaluatePcode [epGetIntegerArraySize]: bad stack element type"));
  1395.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  1396.                                 {
  1397.                                     ErrorCode = eEvalArrayDoesntExist;
  1398.                                     goto ExceptionPoint;
  1399.                                 }
  1400.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle);
  1401.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  1402.                             Index = PtrSize((char*)(Stack[StackPtr].Data.ArrayHandle->Array))
  1403.                                 / sizeof(long);
  1404.                             DisposeIfNotOnStack(Stack,StackPtr);
  1405.                             Stack[StackPtr].ElementType = esScalar;
  1406.                             Stack[StackPtr].Data.Integer = Index;
  1407.                             break;
  1408.                         case epGetFloatArraySize:
  1409.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1410.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1411.                                 "EvaluatePcode [epGetFloatArraySize]: bad stack element type"));
  1412.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  1413.                                 {
  1414.                                     ErrorCode = eEvalArrayDoesntExist;
  1415.                                     goto ExceptionPoint;
  1416.                                 }
  1417.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle);
  1418.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  1419.                             Index = PtrSize((char*)(Stack[StackPtr].Data.ArrayHandle->Array))
  1420.                                 / sizeof(float);
  1421.                             DisposeIfNotOnStack(Stack,StackPtr);
  1422.                             Stack[StackPtr].ElementType = esScalar;
  1423.                             Stack[StackPtr].Data.Integer = Index;
  1424.                             break;
  1425.                         case epGetDoubleArraySize:
  1426.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1427.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1428.                                 "EvaluatePcode [epGetDoubleArraySize]: bad stack element type"));
  1429.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  1430.                                 {
  1431.                                     ErrorCode = eEvalArrayDoesntExist;
  1432.                                     goto ExceptionPoint;
  1433.                                 }
  1434.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle);
  1435.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  1436.                             Index = PtrSize((char*)(Stack[StackPtr].Data.ArrayHandle->Array))
  1437.                                 / sizeof(double);
  1438.                             DisposeIfNotOnStack(Stack,StackPtr);
  1439.                             Stack[StackPtr].ElementType = esScalar;
  1440.                             Stack[StackPtr].Data.Integer = Index;
  1441.                             break;
  1442.                         case epGetFixedArraySize:
  1443.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1444.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1445.                                 "EvaluatePcode [epGetFixedArraySize]: bad stack element type"));
  1446.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  1447.                                 {
  1448.                                     ErrorCode = eEvalArrayDoesntExist;
  1449.                                     goto ExceptionPoint;
  1450.                                 }
  1451.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle);
  1452.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  1453.                             Index = PtrSize((char*)(Stack[StackPtr].Data.ArrayHandle->Array))
  1454.                                 / sizeof(largefixedsigned);
  1455.                             DisposeIfNotOnStack(Stack,StackPtr);
  1456.                             Stack[StackPtr].ElementType = esScalar;
  1457.                             Stack[StackPtr].Data.Integer = Index;
  1458.                             break;
  1459.  
  1460.                         case epResizeBooleanArray2:
  1461.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1462.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1463.                                 "EvaluatePcode [epResizeBooleanArray]: bad stack element type"));
  1464.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1465.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1466.                                 "EvaluatePcode [epResizeBooleanArray2]:  array slot of wrong type"));
  1467.                             if (Stack[StackPtr].Data.Integer < 0)
  1468.                                 {
  1469.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1470.                                     goto ExceptionPoint;
  1471.                                 }
  1472.                             if (Stack[StackPtr - 1].Data.ArrayHandle != NIL)
  1473.                                 {
  1474.                                     void*                    OldReference;
  1475.                                     void*                    NewReference;
  1476.                                     long                    SizeDifference;
  1477.  
  1478.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  1479.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  1480.                                     OldReference = Stack[StackPtr - 1].Data.ArrayHandle->Array;
  1481.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1482.                                         - (PtrSize((char*)OldReference) / sizeof(char));
  1483.                                     NewReference = ResizePtr((char*)OldReference,
  1484.                                         Stack[StackPtr].Data.Integer);
  1485.                                     if (NewReference == NIL)
  1486.                                         {
  1487.                                             ErrorCode = eEvalOutOfMemory;
  1488.                                             goto ExceptionPoint;
  1489.                                         }
  1490.                                     /* now patch up the references */
  1491.                                     Stack[StackPtr - 1].Data.ArrayHandle->Array = NewReference;
  1492.                                     /* if we added to the array, then we have to zero those elements */
  1493.                                     if (SizeDifference > 0)
  1494.                                         {
  1495.                                             long                    Limit;
  1496.  
  1497.                                             Limit = Stack[StackPtr].Data.Integer;
  1498.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1499.                                                 {
  1500.                                                     PRNGCHK(NewReference,&(((char*)NewReference)[Index]),
  1501.                                                         sizeof(char));
  1502.                                                     ((char*)NewReference)[Index] = 0;
  1503.                                                 }
  1504.                                         }
  1505.                                 }
  1506.                              else
  1507.                                 {
  1508.                                     ErrorCode = eEvalArrayDoesntExist;
  1509.                                     goto ExceptionPoint;
  1510.                                 }
  1511.                             StackPtr -= 1;
  1512.                             break;
  1513.                         case epResizeIntegerArray2:
  1514.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1515.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1516.                                 "EvaluatePcode [epResizeIntegerArray]: bad stack element type"));
  1517.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1518.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1519.                                 "EvaluatePcode [epResizeIntegerArray]:  array slot of wrong type"));
  1520.                             if (Stack[StackPtr].Data.Integer < 0)
  1521.                                 {
  1522.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1523.                                     goto ExceptionPoint;
  1524.                                 }
  1525.                             if (Stack[StackPtr - 1].Data.ArrayHandle != NIL)
  1526.                                 {
  1527.                                     void*                    OldReference;
  1528.                                     void*                    NewReference;
  1529.                                     long                    SizeDifference;
  1530.  
  1531.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  1532.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  1533.                                     OldReference = Stack[StackPtr - 1].Data.ArrayHandle->Array;
  1534.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1535.                                         - (PtrSize((char*)OldReference) / sizeof(long));
  1536.                                     NewReference = ResizePtr((char*)OldReference,
  1537.                                         Stack[StackPtr].Data.Integer * sizeof(long));
  1538.                                     if (NewReference == NIL)
  1539.                                         {
  1540.                                             ErrorCode = eEvalOutOfMemory;
  1541.                                             goto ExceptionPoint;
  1542.                                         }
  1543.                                     /* now patch up the references */
  1544.                                     Stack[StackPtr - 1].Data.ArrayHandle->Array = NewReference;
  1545.                                     /* if we added to the array, then we have to zero those elements */
  1546.                                     if (SizeDifference > 0)
  1547.                                         {
  1548.                                             long                    Limit;
  1549.  
  1550.                                             Limit = Stack[StackPtr].Data.Integer;
  1551.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1552.                                                 {
  1553.                                                     PRNGCHK(NewReference,&(((long*)NewReference)[Index]),
  1554.                                                         sizeof(long));
  1555.                                                     ((long*)NewReference)[Index] = 0;
  1556.                                                 }
  1557.                                         }
  1558.                                 }
  1559.                              else
  1560.                                 {
  1561.                                     ErrorCode = eEvalArrayDoesntExist;
  1562.                                     goto ExceptionPoint;
  1563.                                 }
  1564.                             StackPtr -= 1;
  1565.                             break;
  1566.                         case epResizeFloatArray2:
  1567.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1568.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1569.                                 "EvaluatePcode [epResizeFloatArray]: bad stack element type"));
  1570.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1571.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1572.                                 "EvaluatePcode [epResizeFloatArray]:  array slot of wrong type"));
  1573.                             if (Stack[StackPtr].Data.Integer < 0)
  1574.                                 {
  1575.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1576.                                     goto ExceptionPoint;
  1577.                                 }
  1578.                             if (Stack[StackPtr - 1].Data.ArrayHandle != NIL)
  1579.                                 {
  1580.                                     void*                    OldReference;
  1581.                                     void*                    NewReference;
  1582.                                     long                    SizeDifference;
  1583.  
  1584.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  1585.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  1586.                                     OldReference = Stack[StackPtr - 1].Data.ArrayHandle->Array;
  1587.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1588.                                         - (PtrSize((char*)OldReference) / sizeof(float));
  1589.                                     NewReference = ResizePtr((char*)OldReference,
  1590.                                         Stack[StackPtr].Data.Integer * sizeof(float));
  1591.                                     if (NewReference == NIL)
  1592.                                         {
  1593.                                             ErrorCode = eEvalOutOfMemory;
  1594.                                             goto ExceptionPoint;
  1595.                                         }
  1596.                                     /* now patch up the references */
  1597.                                     Stack[StackPtr - 1].Data.ArrayHandle->Array = NewReference;
  1598.                                     /* if we added to the array, then we have to zero those elements */
  1599.                                     if (SizeDifference > 0)
  1600.                                         {
  1601.                                             long                    Limit;
  1602.  
  1603.                                             Limit = Stack[StackPtr].Data.Integer;
  1604.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1605.                                                 {
  1606.                                                     PRNGCHK(NewReference,&(((float*)NewReference)[Index]),
  1607.                                                         sizeof(float));
  1608.                                                     ((float*)NewReference)[Index] = 0;
  1609.                                                 }
  1610.                                         }
  1611.                                 }
  1612.                              else
  1613.                                 {
  1614.                                     ErrorCode = eEvalArrayDoesntExist;
  1615.                                     goto ExceptionPoint;
  1616.                                 }
  1617.                             StackPtr -= 1;
  1618.                             break;
  1619.                         case epResizeDoubleArray2:
  1620.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1621.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1622.                                 "EvaluatePcode [epResizeDoubleArray]: bad stack element type"));
  1623.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1624.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1625.                                 "EvaluatePcode [epResizeDoubleArray]:  array slot of wrong type"));
  1626.                             if (Stack[StackPtr].Data.Integer < 0)
  1627.                                 {
  1628.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1629.                                     goto ExceptionPoint;
  1630.                                 }
  1631.                             if (Stack[StackPtr - 1].Data.ArrayHandle != NIL)
  1632.                                 {
  1633.                                     void*                    OldReference;
  1634.                                     void*                    NewReference;
  1635.                                     long                    SizeDifference;
  1636.  
  1637.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  1638.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  1639.                                     OldReference = Stack[StackPtr - 1].Data.ArrayHandle->Array;
  1640.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1641.                                         - (PtrSize((char*)OldReference) / sizeof(double));
  1642.                                     NewReference = ResizePtr((char*)OldReference,
  1643.                                         Stack[StackPtr].Data.Integer * sizeof(double));
  1644.                                     if (NewReference == NIL)
  1645.                                         {
  1646.                                             ErrorCode = eEvalOutOfMemory;
  1647.                                             goto ExceptionPoint;
  1648.                                         }
  1649.                                     /* now patch up the references */
  1650.                                     Stack[StackPtr - 1].Data.ArrayHandle->Array = NewReference;
  1651.                                     /* if we added to the array, then we have to zero those elements */
  1652.                                     if (SizeDifference > 0)
  1653.                                         {
  1654.                                             long                    Limit;
  1655.  
  1656.                                             Limit = Stack[StackPtr].Data.Integer;
  1657.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1658.                                                 {
  1659.                                                     PRNGCHK(NewReference,&(((double*)NewReference)[Index]),
  1660.                                                         sizeof(double));
  1661.                                                     ((double*)NewReference)[Index] = 0;
  1662.                                                 }
  1663.                                         }
  1664.                                 }
  1665.                              else
  1666.                                 {
  1667.                                     ErrorCode = eEvalArrayDoesntExist;
  1668.                                     goto ExceptionPoint;
  1669.                                 }
  1670.                             StackPtr -= 1;
  1671.                             break;
  1672.                         case epResizeFixedArray2:
  1673.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1674.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1675.                                 "EvaluatePcode [epResizeFixedArray]: bad stack element type"));
  1676.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1677.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1678.                                 "EvaluatePcode [epResizeFixedArray]:  array slot of wrong type"));
  1679.                             if (Stack[StackPtr].Data.Integer < 0)
  1680.                                 {
  1681.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1682.                                     goto ExceptionPoint;
  1683.                                 }
  1684.                             if (Stack[StackPtr - 1].Data.ArrayHandle != NIL)
  1685.                                 {
  1686.                                     void*                    OldReference;
  1687.                                     void*                    NewReference;
  1688.                                     long                    SizeDifference;
  1689.  
  1690.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  1691.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  1692.                                     OldReference = Stack[StackPtr - 1].Data.ArrayHandle->Array;
  1693.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1694.                                         - (PtrSize((char*)OldReference) / sizeof(largefixedsigned));
  1695.                                     NewReference = ResizePtr((char*)OldReference,
  1696.                                         Stack[StackPtr].Data.Integer * sizeof(largefixedsigned));
  1697.                                     if (NewReference == NIL)
  1698.                                         {
  1699.                                             ErrorCode = eEvalOutOfMemory;
  1700.                                             goto ExceptionPoint;
  1701.                                         }
  1702.                                     /* now patch up the references */
  1703.                                     Stack[StackPtr - 1].Data.ArrayHandle->Array = NewReference;
  1704.                                     /* if we added to the array, then we have to zero those elements */
  1705.                                     if (SizeDifference > 0)
  1706.                                         {
  1707.                                             long                    Limit;
  1708.  
  1709.                                             Limit = Stack[StackPtr].Data.Integer;
  1710.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1711.                                                 {
  1712.                                                     PRNGCHK(NewReference,
  1713.                                                         &(((largefixedsigned*)NewReference)[Index]),
  1714.                                                         sizeof(largefixedsigned));
  1715.                                                     ((largefixedsigned*)NewReference)[Index] = 0;
  1716.                                                 }
  1717.                                         }
  1718.                                 }
  1719.                              else
  1720.                                 {
  1721.                                     ErrorCode = eEvalArrayDoesntExist;
  1722.                                     goto ExceptionPoint;
  1723.                                 }
  1724.                             StackPtr -= 1;
  1725.                             break;
  1726.  
  1727.                         case epStoreIntegerOnStack:
  1728.                             /*    -1         0    */
  1729.                             /* <opcode> <stackindex> */
  1730.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1731.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1732.                                 "EvaluatePcode [epStoreIntegerOnStack]: bad stack element type"));
  1733.                             PRNGCHK(CurrentProcedure,
  1734.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1735.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1736.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1737.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1738.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1739.                                 "EvaluatePcode [epStoreIntegerOnStack]:  array slot of wrong type"));
  1740.                             Stack[Index].Data.Integer = Stack[StackPtr].Data.Integer;
  1741.                             ProgramCounter += 1;
  1742.                             /* don't pop the value from the stack though */
  1743.                             break;
  1744.                         case epStoreFloatOnStack:
  1745.                             /*    -1         0    */
  1746.                             /* <opcode> <stackindex> */
  1747.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1748.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1749.                                 "EvaluatePcode [epStoreFloatOnStack]: bad stack element type"));
  1750.                             PRNGCHK(CurrentProcedure,
  1751.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1752.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1753.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1754.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1755.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1756.                                 "EvaluatePcode [epStoreFloatOnStack]:  array slot of wrong type"));
  1757.                             Stack[Index].Data.Float = Stack[StackPtr].Data.Float;
  1758.                             ProgramCounter += 1;
  1759.                             /* don't pop the value from the stack though */
  1760.                             break;
  1761.                         case epStoreDoubleOnStack:
  1762.                             /*    -1         0    */
  1763.                             /* <opcode> <stackindex> */
  1764.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1765.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1766.                                 "EvaluatePcode [epStoreDoubleOnStack]: bad stack element type"));
  1767.                             PRNGCHK(CurrentProcedure,
  1768.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1769.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1770.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1771.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1772.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1773.                                 "EvaluatePcode [epStoreDoubleOnStack]:  array slot of wrong type"));
  1774.                             Stack[Index].Data.Double = Stack[StackPtr].Data.Double;
  1775.                             ProgramCounter += 1;
  1776.                             /* don't pop the value from the stack though */
  1777.                             break;
  1778.                         case epStoreArrayOnStack:
  1779.                             /*    -1         0    */
  1780.                             /* <opcode> <stackindex> */
  1781.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1782.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1783.                                 "EvaluatePcode [epStoreArrayOnStack]: bad stack element type"));
  1784.                             /* this one has to make sure it deallocates an array that it overwrites. */
  1785.                             PRNGCHK(CurrentProcedure,
  1786.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1787.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1788.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1789.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1790.                             ERROR((Stack[Index].ElementType != esScalar)
  1791.                                 && (Stack[Index].ElementType != esArray),
  1792.                                 PRERR(ForceAbort,
  1793.                                 "EvaluatePcode [epStoreArrayOnStack]:  array slot of wrong type"));
  1794.                             if ((Stack[Index].ElementType == esArray)
  1795.                                 && (Stack[Index].Data.ArrayHandle != NIL))
  1796.                                 {
  1797.                                     DisposeIfOnStackOnlyOnce(Stack,StackPtr,Index);
  1798.                                 }
  1799.                             Stack[Index].Data.ArrayHandle = Stack[StackPtr].Data.ArrayHandle;
  1800.                             if (Stack[Index].Data.ArrayHandle != NIL)
  1801.                                 {
  1802.                                     /* increment the reference count */
  1803.                                     Stack[Index].Data.ArrayHandle->RefCount += 1;
  1804.                                 }
  1805.                             Stack[Index].ElementType = esArray;
  1806.                             ProgramCounter += 1;
  1807.                             /* don't pop the value from the stack though */
  1808.                             break;
  1809.                         case epLoadIntegerFromStack:
  1810.                             /*    -1         0    */
  1811.                             /* <opcode> <stackindex> */
  1812.                             PRNGCHK(CurrentProcedure,
  1813.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1814.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1815.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1816.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1817.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1818.                                 "EvaluatePcode [epLoadIntegerFromStack]:  array slot of wrong type"));
  1819.                             StackPtr += 1;
  1820.                             if (StackPtr >= StackSize)
  1821.                                 {
  1822.                                     StackElement*            NewStack;
  1823.  
  1824.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1825.                                         * sizeof(StackElement));
  1826.                                     if (NewStack == NIL)
  1827.                                         {
  1828.                                             StackPtr -= 1;
  1829.                                             ErrorCode = eEvalOutOfMemory;
  1830.                                             goto ExceptionPoint;
  1831.                                         }
  1832.                                     Stack = NewStack;
  1833.                                     StackSize += 8;
  1834.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1835.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadIntegerFromStack]: stack size inconsistency"));
  1836.                                 }
  1837.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1838.                             Stack[StackPtr].ElementType = esScalar;
  1839.                             Stack[StackPtr].Data.Integer = Stack[Index].Data.Integer;
  1840.                             ProgramCounter += 1;
  1841.                             break;
  1842.                         case epLoadFloatFromStack:
  1843.                             /*    -1         0    */
  1844.                             /* <opcode> <stackindex> */
  1845.                             PRNGCHK(CurrentProcedure,
  1846.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1847.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1848.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1849.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1850.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1851.                                 "EvaluatePcode [epLoadFloatFromStack]:  array slot of wrong type"));
  1852.                             StackPtr += 1;
  1853.                             if (StackPtr >= StackSize)
  1854.                                 {
  1855.                                     StackElement*            NewStack;
  1856.  
  1857.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1858.                                         * sizeof(StackElement));
  1859.                                     if (NewStack == NIL)
  1860.                                         {
  1861.                                             StackPtr -= 1;
  1862.                                             ErrorCode = eEvalOutOfMemory;
  1863.                                             goto ExceptionPoint;
  1864.                                         }
  1865.                                     Stack = NewStack;
  1866.                                     StackSize += 8;
  1867.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1868.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadFloatFromStack]: stack size inconsistency"));
  1869.                                 }
  1870.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1871.                             Stack[StackPtr].ElementType = esScalar;
  1872.                             Stack[StackPtr].Data.Float = Stack[Index].Data.Float;
  1873.                             ProgramCounter += 1;
  1874.                             break;
  1875.                         case epLoadDoubleFromStack:
  1876.                             /*    -1         0    */
  1877.                             /* <opcode> <stackindex> */
  1878.                             PRNGCHK(CurrentProcedure,
  1879.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1880.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1881.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1882.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1883.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1884.                                 "EvaluatePcode [epLoadDoubleFromStack]:  array slot of wrong type"));
  1885.                             StackPtr += 1;
  1886.                             if (StackPtr >= StackSize)
  1887.                                 {
  1888.                                     StackElement*            NewStack;
  1889.  
  1890.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1891.                                         * sizeof(StackElement));
  1892.                                     if (NewStack == NIL)
  1893.                                         {
  1894.                                             StackPtr -= 1;
  1895.                                             ErrorCode = eEvalOutOfMemory;
  1896.                                             goto ExceptionPoint;
  1897.                                         }
  1898.                                     Stack = NewStack;
  1899.                                     StackSize += 8;
  1900.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1901.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadDoubleFromStack]: stack size inconsistency"));
  1902.                                 }
  1903.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1904.                             Stack[StackPtr].ElementType = esScalar;
  1905.                             Stack[StackPtr].Data.Double = Stack[Index].Data.Double;
  1906.                             ProgramCounter += 1;
  1907.                             break;
  1908.                         case epLoadArrayFromStack:
  1909.                             /*    -1         0    */
  1910.                             /* <opcode> <stackindex> */
  1911.                             PRNGCHK(CurrentProcedure,
  1912.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1913.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1914.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1915.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1916.                             ERROR(Stack[Index].ElementType != esArray,PRERR(ForceAbort,
  1917.                                 "EvaluatePcode [epLoadArrayFromStack]:  array slot of wrong type"));
  1918.                             StackPtr += 1;
  1919.                             if (StackPtr >= StackSize)
  1920.                                 {
  1921.                                     StackElement*            NewStack;
  1922.  
  1923.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1924.                                         * sizeof(StackElement));
  1925.                                     if (NewStack == NIL)
  1926.                                         {
  1927.                                             StackPtr -= 1;
  1928.                                             ErrorCode = eEvalOutOfMemory;
  1929.                                             goto ExceptionPoint;
  1930.                                         }
  1931.                                     Stack = NewStack;
  1932.                                     StackSize += 8;
  1933.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1934.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadArrayFromStack]: stack size inconsistency"));
  1935.                                 }
  1936.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1937.                             Stack[StackPtr].Data.ArrayHandle = Stack[Index].Data.ArrayHandle;
  1938.                             if (Stack[StackPtr].Data.ArrayHandle != NIL)
  1939.                                 {
  1940.                                     /* increment the reference count */
  1941.                                     Stack[StackPtr].Data.ArrayHandle->RefCount += 1;
  1942.                                 }
  1943.                             Stack[StackPtr].ElementType = esArray;
  1944.                             ProgramCounter += 1;
  1945.                             break;
  1946.  
  1947.                         case epStackPop:
  1948.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1949.                             if ((Stack[StackPtr].ElementType == esArray)
  1950.                                 && (Stack[StackPtr].Data.ArrayHandle != NIL))
  1951.                                 {
  1952.                                     DisposeIfNotOnStack(Stack,StackPtr);
  1953.                                 }
  1954.                             StackPtr -= 1;
  1955.                             break;
  1956.  
  1957.                         case epStackAllocate:
  1958.                             StackPtr += 1;
  1959.                             if (StackPtr >= StackSize)
  1960.                                 {
  1961.                                     StackElement*            NewStack;
  1962.  
  1963.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1964.                                         * sizeof(StackElement));
  1965.                                     if (NewStack == NIL)
  1966.                                         {
  1967.                                             StackPtr -= 1;
  1968.                                             ErrorCode = eEvalOutOfMemory;
  1969.                                             goto ExceptionPoint;
  1970.                                         }
  1971.                                     Stack = NewStack;
  1972.                                     StackSize += 8;
  1973.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1974.                                         PRERR(ForceAbort,"EvaluatePcode [epStackAllocate]: stack size inconsistency"));
  1975.                                 }
  1976.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1977.                             Stack[StackPtr].ElementType = esScalar;
  1978.                             break;
  1979.  
  1980.                         case epStackPopMultiple:
  1981.                             /*     -1       0   */
  1982.                             /* <opcode> <numwords> */
  1983.                             PRNGCHK(CurrentProcedure,
  1984.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1985.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1986.                             Index = CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1987.                             while (Index > 0)
  1988.                                 {
  1989.                                     PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1990.                                     if ((Stack[StackPtr].ElementType == esArray)
  1991.                                         && (Stack[StackPtr].Data.ArrayHandle != NIL))
  1992.                                         {
  1993.                                             DisposeIfNotOnStack(Stack,StackPtr);
  1994.                                         }
  1995.                                     StackPtr -= 1;
  1996.                                     Index -= 1;
  1997.                                 }
  1998.                             ProgramCounter += 1;
  1999.                             break;
  2000.  
  2001.                         /* deallocate multiple cells under the current top */
  2002.                         case epStackDeallocateUnder:
  2003.                             /*    -1        0   */
  2004.                             /* <opcode> <numwords> */
  2005.                             PRNGCHK(CurrentProcedure,
  2006.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  2007.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  2008.                             /* get the number of cells to deallocate */
  2009.                             Index = CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  2010.                             Scan = StackPtr;
  2011.                             while (Index > 0)
  2012.                                 {
  2013.                                     PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2014.                                     if ((Stack[StackPtr - 1].ElementType == esArray)
  2015.                                         && (Stack[StackPtr - 1].Data.ArrayHandle != NIL))
  2016.                                         {
  2017.                                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2018.                                         }
  2019.                                     PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2020.                                     Stack[StackPtr - 1] = Stack[StackPtr];
  2021.                                     StackPtr -= 1;
  2022.                                     Index -= 1;
  2023.                                 }
  2024.                             Stack[StackPtr] = Stack[Scan];
  2025.                             ProgramCounter += 1;
  2026.                             break;
  2027.  
  2028.                         /* duplicate the top word of the stack */
  2029.                         case epDuplicate:
  2030.                             StackPtr += 1;
  2031.                             if (StackPtr >= StackSize)
  2032.                                 {
  2033.                                     StackElement*            NewStack;
  2034.  
  2035.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2036.                                         * sizeof(StackElement));
  2037.                                     if (NewStack == NIL)
  2038.                                         {
  2039.                                             StackPtr -= 1;
  2040.                                             ErrorCode = eEvalOutOfMemory;
  2041.                                             goto ExceptionPoint;
  2042.                                         }
  2043.                                     Stack = NewStack;
  2044.                                     StackSize += 8;
  2045.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2046.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadDoubleFromStack]: stack size inconsistency"));
  2047.                                 }
  2048.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2049.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2050.                             Stack[StackPtr] = Stack[StackPtr - 1];
  2051.                             if ((Stack[StackPtr].ElementType == esArray)
  2052.                                 && (Stack[StackPtr].Data.ArrayHandle != NIL))
  2053.                                 {
  2054.                                     /* increment the reference count */
  2055.                                     Stack[StackPtr].Data.ArrayHandle->RefCount += 1;
  2056.                                 }
  2057.                             break;
  2058.  
  2059.                         /* no operation */
  2060.                         case epNop:
  2061.                             break;
  2062.  
  2063.                         /* new array allocation procedures */
  2064.                         case epMakeBooleanArray:
  2065.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2066.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2067.                                 "EvaluatePcode [epMakeBooleanArray]: bad stack element type"));
  2068.                             Index = Stack[StackPtr].Data.Integer;
  2069.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2070.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2071.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2072.                                 {
  2073.                                     ErrorCode = eEvalOutOfMemory;
  2074.                                     goto ExceptionPoint;
  2075.                                 }
  2076.                             Stack[StackPtr].Data.ArrayHandle->Array = AllocPtrCanFail(Index,
  2077.                                 "EvalPcodeBoolArray");
  2078.                             if (Stack[StackPtr].Data.ArrayHandle->Array == NIL)
  2079.                                 {
  2080.                                     ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2081.                                     Stack[StackPtr].Data.ArrayHandle = NIL;
  2082.                                     ErrorCode = eEvalOutOfMemory;
  2083.                                     goto ExceptionPoint;
  2084.                                 }
  2085.                             Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2086.                             Stack[StackPtr].ElementType = esArray;
  2087.                             for (Scan = 0; Scan < Index; Scan += 1)
  2088.                                 {
  2089.                                     PRNGCHK(Stack[StackPtr].Data.ArrayHandle->Array,
  2090.                                         &(((char*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan]),
  2091.                                         sizeof(char));
  2092.                                     ((char*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan] = 0;
  2093.                                 }
  2094.                             break;
  2095.                         case epMakeIntegerArray:
  2096.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2097.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2098.                                 "EvaluatePcode [epMakeIntegerArray]: bad stack element type"));
  2099.                             Index = Stack[StackPtr].Data.Integer;
  2100.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2101.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2102.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2103.                                 {
  2104.                                     ErrorCode = eEvalOutOfMemory;
  2105.                                     goto ExceptionPoint;
  2106.                                 }
  2107.                             Stack[StackPtr].Data.ArrayHandle->Array = AllocPtrCanFail(
  2108.                                 Index * sizeof(long),"EvalPcodeIntArray");
  2109.                             if (Stack[StackPtr].Data.ArrayHandle->Array == NIL)
  2110.                                 {
  2111.                                     ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2112.                                     Stack[StackPtr].Data.ArrayHandle = NIL;
  2113.                                     ErrorCode = eEvalOutOfMemory;
  2114.                                     goto ExceptionPoint;
  2115.                                 }
  2116.                             Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2117.                             Stack[StackPtr].ElementType = esArray;
  2118.                             for (Scan = 0; Scan < Index; Scan += 1)
  2119.                                 {
  2120.                                     PRNGCHK(Stack[StackPtr].Data.ArrayHandle->Array,
  2121.                                         &(((long*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan]),
  2122.                                         sizeof(long));
  2123.                                     ((long*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan] = 0;
  2124.                                 }
  2125.                             break;
  2126.                         case epMakeFloatArray:
  2127.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2128.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2129.                                 "EvaluatePcode [epMakeFloatArray]: bad stack element type"));
  2130.                             Index = Stack[StackPtr].Data.Integer;
  2131.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2132.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2133.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2134.                                 {
  2135.                                     ErrorCode = eEvalOutOfMemory;
  2136.                                     goto ExceptionPoint;
  2137.                                 }
  2138.                             Stack[StackPtr].Data.ArrayHandle->Array = AllocPtrCanFail(
  2139.                                 Index * sizeof(float),"EvalPcodeFloatArray");
  2140.                             if (Stack[StackPtr].Data.ArrayHandle->Array == NIL)
  2141.                                 {
  2142.                                     ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2143.                                     Stack[StackPtr].Data.ArrayHandle = NIL;
  2144.                                     ErrorCode = eEvalOutOfMemory;
  2145.                                     goto ExceptionPoint;
  2146.                                 }
  2147.                             Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2148.                             Stack[StackPtr].ElementType = esArray;
  2149.                             for (Scan = 0; Scan < Index; Scan += 1)
  2150.                                 {
  2151.                                     PRNGCHK(Stack[StackPtr].Data.ArrayHandle->Array,
  2152.                                         &(((float*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan]),
  2153.                                         sizeof(float));
  2154.                                     ((float*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan] = 0;
  2155.                                 }
  2156.                             break;
  2157.                         case epMakeDoubleArray:
  2158.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2159.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2160.                                 "EvaluatePcode [epMakeDoubleArray]: bad stack element type"));
  2161.                             Index = Stack[StackPtr].Data.Integer;
  2162.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2163.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2164.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2165.                                 {
  2166.                                     ErrorCode = eEvalOutOfMemory;
  2167.                                     goto ExceptionPoint;
  2168.                                 }
  2169.                             Stack[StackPtr].Data.ArrayHandle->Array = AllocPtrCanFail(
  2170.                                 Index * sizeof(double),"EvalPcodeDoubleArray");
  2171.                             if (Stack[StackPtr].Data.ArrayHandle->Array == NIL)
  2172.                                 {
  2173.                                     ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2174.                                     Stack[StackPtr].Data.ArrayHandle = NIL;
  2175.                                     ErrorCode = eEvalOutOfMemory;
  2176.                                     goto ExceptionPoint;
  2177.                                 }
  2178.                             Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2179.                             Stack[StackPtr].ElementType = esArray;
  2180.                             for (Scan = 0; Scan < Index; Scan += 1)
  2181.                                 {
  2182.                                     PRNGCHK(Stack[StackPtr].Data.ArrayHandle->Array,
  2183.                                         &(((double*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan]),
  2184.                                         sizeof(double));
  2185.                                     ((double*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan] = 0;
  2186.                                 }
  2187.                             break;
  2188.                         case epMakeFixedArray:
  2189.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2190.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2191.                                 "EvaluatePcode [epMakeFixedArray]: bad stack element type"));
  2192.                             Index = Stack[StackPtr].Data.Integer;
  2193.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2194.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2195.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2196.                                 {
  2197.                                     ErrorCode = eEvalOutOfMemory;
  2198.                                     goto ExceptionPoint;
  2199.                                 }
  2200.                             Stack[StackPtr].Data.ArrayHandle->Array = AllocPtrCanFail(
  2201.                                 Index * sizeof(long),"EvalPcodeFixedArray");
  2202.                             if (Stack[StackPtr].Data.ArrayHandle->Array == NIL)
  2203.                                 {
  2204.                                     ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2205.                                     Stack[StackPtr].Data.ArrayHandle = NIL;
  2206.                                     ErrorCode = eEvalOutOfMemory;
  2207.                                     goto ExceptionPoint;
  2208.                                 }
  2209.                             Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2210.                             Stack[StackPtr].ElementType = esArray;
  2211.                             for (Scan = 0; Scan < Index; Scan += 1)
  2212.                                 {
  2213.                                     PRNGCHK(Stack[StackPtr].Data.ArrayHandle->Array,
  2214.                                         &(((largefixedsigned*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan]),
  2215.                                         sizeof(largefixedsigned));
  2216.                                     ((largefixedsigned*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan] = 0;
  2217.                                 }
  2218.                             break;
  2219.  
  2220.                         case epStoreBooleanIntoArray2:
  2221.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2222.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2223.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2224.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2225.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2226.                                 "EvaluatePcode [epStoreBooleanIntoArray]: bad stack element type"));
  2227.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2228.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2229.                                 "EvaluatePcode [epStoreBooleanIntoArray]:  not an array"));
  2230.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2231.                                 {
  2232.                                     ErrorCode = eEvalArrayDoesntExist;
  2233.                                     goto ExceptionPoint;
  2234.                                 }
  2235.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2236.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2237.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2238.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)))
  2239.                                 {
  2240.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2241.                                     goto ExceptionPoint;
  2242.                                 }
  2243.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2244.                                 &(((char*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2245.                                 Stack[StackPtr].Data.Integer]),sizeof(char));
  2246.                             ((char*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2247.                                 Stack[StackPtr].Data.Integer] = Stack[StackPtr - 2].Data.Integer;
  2248.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2249.                             StackPtr -= 2; /* pop subscript and reference */
  2250.                             break;
  2251.                         case epStoreIntegerIntoArray2:
  2252.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2253.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2254.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2255.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2256.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2257.                                 "EvaluatePcode [epStoreIntegerIntoArray]: bad stack element type"));
  2258.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2259.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2260.                                 "EvaluatePcode [epStoreIntegerIntoArray]:  not an array"));
  2261.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2262.                                 {
  2263.                                     ErrorCode = eEvalArrayDoesntExist;
  2264.                                     goto ExceptionPoint;
  2265.                                 }
  2266.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2267.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2268.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2269.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2270.                                 / sizeof(long)))
  2271.                                 {
  2272.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2273.                                     goto ExceptionPoint;
  2274.                                 }
  2275.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2276.                                 &(((long*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2277.                                 Stack[StackPtr].Data.Integer]),sizeof(long));
  2278.                             ((long*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2279.                                 Stack[StackPtr].Data.Integer] = Stack[StackPtr - 2].Data.Integer;
  2280.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2281.                             StackPtr -= 2; /* pop subscript and reference */
  2282.                             break;
  2283.                         case epStoreFloatIntoArray2:
  2284.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2285.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2286.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2287.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2288.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2289.                                 "EvaluatePcode [epStoreFloatIntoArray]: bad stack element type"));
  2290.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2291.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2292.                                 "EvaluatePcode [epStoreFloatIntoArray]:  not an array"));
  2293.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2294.                                 {
  2295.                                     ErrorCode = eEvalArrayDoesntExist;
  2296.                                     goto ExceptionPoint;
  2297.                                 }
  2298.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2299.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2300.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2301.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2302.                                 / sizeof(float)))
  2303.                                 {
  2304.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2305.                                     goto ExceptionPoint;
  2306.                                 }
  2307.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2308.                                 &(((float*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2309.                                 Stack[StackPtr].Data.Integer]),sizeof(float));
  2310.                             ((float*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2311.                                 Stack[StackPtr].Data.Integer] = Stack[StackPtr - 2].Data.Float;
  2312.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2313.                             StackPtr -= 2; /* pop subscript and reference */
  2314.                             break;
  2315.                         case epStoreDoubleIntoArray2:
  2316.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2317.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2318.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2319.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2320.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2321.                                 "EvaluatePcode [epStoreDoubleIntoArray]: bad stack element type"));
  2322.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2323.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2324.                                 "EvaluatePcode [epStoreDoubleIntoArray]:  not an array"));
  2325.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2326.                                 {
  2327.                                     ErrorCode = eEvalArrayDoesntExist;
  2328.                                     goto ExceptionPoint;
  2329.                                 }
  2330.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2331.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2332.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2333.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2334.                                 / sizeof(double)))
  2335.                                 {
  2336.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2337.                                     goto ExceptionPoint;
  2338.                                 }
  2339.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2340.                                 &(((double*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2341.                                 Stack[StackPtr].Data.Integer]),sizeof(double));
  2342.                             ((double*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2343.                                 Stack[StackPtr].Data.Integer] = Stack[StackPtr - 2].Data.Double;
  2344.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2345.                             StackPtr -= 2; /* pop subscript and reference */
  2346.                             break;
  2347.                         case epStoreFixedIntoArray2:
  2348.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2349.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2350.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2351.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2352.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2353.                                 "EvaluatePcode [epStoreFixedIntoArray]: bad stack element type"));
  2354.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2355.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2356.                                 "EvaluatePcode [epStoreFixedIntoArray]:  not an array"));
  2357.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2358.                                 {
  2359.                                     ErrorCode = eEvalArrayDoesntExist;
  2360.                                     goto ExceptionPoint;
  2361.                                 }
  2362.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2363.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2364.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2365.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2366.                                 / sizeof(largefixedsigned)))
  2367.                                 {
  2368.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2369.                                     goto ExceptionPoint;
  2370.                                 }
  2371.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2372.                                 &(((largefixedsigned*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2373.                                 Stack[StackPtr].Data.Integer]),sizeof(largefixedsigned));
  2374.                             ((largefixedsigned*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2375.                                 Stack[StackPtr].Data.Integer] = Stack[StackPtr - 2].Data.Integer;
  2376.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2377.                             StackPtr -= 2; /* pop subscript and reference */
  2378.                             break;
  2379.  
  2380.                         case epLoadBooleanFromArray2:
  2381.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2382.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2383.                                 "EvaluatePcode [epLoadBooleanFromArray]: bad stack element type"));
  2384.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2385.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2386.                                 "EvaluatePcode [epLoadBooleanFromArray]:  not an array"));
  2387.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2388.                                 {
  2389.                                     ErrorCode = eEvalArrayDoesntExist;
  2390.                                     goto ExceptionPoint;
  2391.                                 }
  2392.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2393.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2394.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2395.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)))
  2396.                                 {
  2397.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2398.                                     goto ExceptionPoint;
  2399.                                 }
  2400.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2401.                                 &(((char*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2402.                                 Stack[StackPtr].Data.Integer]),sizeof(char));
  2403.                             {
  2404.                                 long                        BoolTemp;
  2405.  
  2406.                                 BoolTemp = ((char*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2407.                                     Stack[StackPtr].Data.Integer];
  2408.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2409.                                 StackPtr -= 1;
  2410.                                 Stack[StackPtr].ElementType = esScalar;
  2411.                                 Stack[StackPtr].Data.Integer = BoolTemp;
  2412.                             }
  2413.                             break;
  2414.                         case epLoadIntegerFromArray2:
  2415.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2416.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2417.                                 "EvaluatePcode [epLoadIntegerFromArray]: bad stack element type"));
  2418.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2419.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2420.                                 "EvaluatePcode [epLoadIntegerFromArray]:  not an array"));
  2421.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2422.                                 {
  2423.                                     ErrorCode = eEvalArrayDoesntExist;
  2424.                                     goto ExceptionPoint;
  2425.                                 }
  2426.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2427.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2428.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2429.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2430.                                 / sizeof(long)))
  2431.                                 {
  2432.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2433.                                     goto ExceptionPoint;
  2434.                                 }
  2435.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2436.                                 &(((long*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2437.                                 Stack[StackPtr].Data.Integer]),sizeof(long));
  2438.                             {
  2439.                                 long                        IntegerTemp;
  2440.  
  2441.                                 IntegerTemp = ((long*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2442.                                     Stack[StackPtr].Data.Integer];
  2443.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2444.                                 StackPtr -= 1;
  2445.                                 Stack[StackPtr].ElementType = esScalar;
  2446.                                 Stack[StackPtr].Data.Integer = IntegerTemp;
  2447.                             }
  2448.                             break;
  2449.                         case epLoadFloatFromArray2:
  2450.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2451.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2452.                                 "EvaluatePcode [epLoadFloatFromArray]: bad stack element type"));
  2453.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2454.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2455.                                 "EvaluatePcode [epLoadFloatFromArray]:  not an array"));
  2456.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2457.                                 {
  2458.                                     ErrorCode = eEvalArrayDoesntExist;
  2459.                                     goto ExceptionPoint;
  2460.                                 }
  2461.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2462.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2463.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2464.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2465.                                 / sizeof(float)))
  2466.                                 {
  2467.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2468.                                     goto ExceptionPoint;
  2469.                                 }
  2470.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2471.                                 &(((float*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2472.                                 Stack[StackPtr].Data.Integer]),sizeof(float));
  2473.                             {
  2474.                                 float                        FloatTemp;
  2475.  
  2476.                                 FloatTemp = ((float*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2477.                                     Stack[StackPtr].Data.Integer];
  2478.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2479.                                 StackPtr -= 1;
  2480.                                 Stack[StackPtr].ElementType = esScalar;
  2481.                                 Stack[StackPtr].Data.Float = FloatTemp;
  2482.                             }
  2483.                             break;
  2484.                         case epLoadDoubleFromArray2:
  2485.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2486.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2487.                                 "EvaluatePcode [epLoadDoubleFromArray]: bad stack element type"));
  2488.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2489.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2490.                                 "EvaluatePcode [epLoadDoubleFromArray]:  not an array"));
  2491.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2492.                                 {
  2493.                                     ErrorCode = eEvalArrayDoesntExist;
  2494.                                     goto ExceptionPoint;
  2495.                                 }
  2496.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2497.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2498.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2499.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2500.                                 / sizeof(double)))
  2501.                                 {
  2502.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2503.                                     goto ExceptionPoint;
  2504.                                 }
  2505.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2506.                                 &(((double*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2507.                                 Stack[StackPtr].Data.Integer]),sizeof(double));
  2508.                             {
  2509.                                 double                        DoubleTemp;
  2510.  
  2511.                                 DoubleTemp = ((double*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2512.                                     Stack[StackPtr].Data.Integer];
  2513.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2514.                                 StackPtr -= 1;
  2515.                                 Stack[StackPtr].ElementType = esScalar;
  2516.                                 Stack[StackPtr].Data.Double = DoubleTemp;
  2517.                             }
  2518.                             break;
  2519.                         case epLoadFixedFromArray2:
  2520.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2521.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2522.                                 "EvaluatePcode [epLoadFixedFromArray]: bad stack element type"));
  2523.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2524.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2525.                                 "EvaluatePcode [epLoadFixedFromArray]:  not an array"));
  2526.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2527.                                 {
  2528.                                     ErrorCode = eEvalArrayDoesntExist;
  2529.                                     goto ExceptionPoint;
  2530.                                 }
  2531.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2532.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2533.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2534.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2535.                                 / sizeof(largefixedsigned)))
  2536.                                 {
  2537.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2538.                                     goto ExceptionPoint;
  2539.                                 }
  2540.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2541.                                 &(((largefixedsigned*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))
  2542.                                 [Stack[StackPtr].Data.Integer]),sizeof(largefixedsigned));
  2543.                             {
  2544.                                 largefixedsigned        FixedTemp;
  2545.  
  2546.                                 FixedTemp = ((largefixedsigned*)(Stack[StackPtr - 1].Data
  2547.                                     .ArrayHandle->Array))[Stack[StackPtr].Data.Integer];
  2548.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2549.                                 StackPtr -= 1;
  2550.                                 Stack[StackPtr].ElementType = esScalar;
  2551.                                 Stack[StackPtr].Data.Integer = FixedTemp;
  2552.                             }
  2553.                             break;
  2554.  
  2555.                         /* load immediate values */
  2556.                         case epLoadImmediateInteger:
  2557.                             /*    -1        0   */
  2558.                             /* <opcode> <integer>; also used for boolean & fixed */
  2559.                             StackPtr += 1;
  2560.                             if (StackPtr >= StackSize)
  2561.                                 {
  2562.                                     StackElement*            NewStack;
  2563.  
  2564.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2565.                                         * sizeof(StackElement));
  2566.                                     if (NewStack == NIL)
  2567.                                         {
  2568.                                             StackPtr -= 1;
  2569.                                             ErrorCode = eEvalOutOfMemory;
  2570.                                             goto ExceptionPoint;
  2571.                                         }
  2572.                                     Stack = NewStack;
  2573.                                     StackSize += 8;
  2574.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2575.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  2576.                                 }
  2577.                             PRNGCHK(CurrentProcedure,
  2578.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  2579.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  2580.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2581.                             Stack[StackPtr].Data.Integer
  2582.                                 = CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  2583.                             Stack[StackPtr].ElementType = esScalar;
  2584.                             ProgramCounter += 1;
  2585.                             break;
  2586.                         case epLoadImmediateFloat:
  2587.                             /*    -1        0   */
  2588.                             /* <opcode> <integer>; also used for boolean & fixed */
  2589.                             StackPtr += 1;
  2590.                             if (StackPtr >= StackSize)
  2591.                                 {
  2592.                                     StackElement*            NewStack;
  2593.  
  2594.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2595.                                         * sizeof(StackElement));
  2596.                                     if (NewStack == NIL)
  2597.                                         {
  2598.                                             StackPtr -= 1;
  2599.                                             ErrorCode = eEvalOutOfMemory;
  2600.                                             goto ExceptionPoint;
  2601.                                         }
  2602.                                     Stack = NewStack;
  2603.                                     StackSize += 8;
  2604.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2605.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  2606.                                 }
  2607.                             PRNGCHK(CurrentProcedure,
  2608.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateFloat),
  2609.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateFloat));
  2610.                             PRNGCHK(CurrentProcedure[ProgramCounter + 0].ImmediateFloat,
  2611.                                 &(*(CurrentProcedure[ProgramCounter + 0].ImmediateFloat)),sizeof(float));
  2612.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2613.                             Stack[StackPtr].Data.Float
  2614.                                 = *(CurrentProcedure[ProgramCounter + 0].ImmediateFloat);
  2615.                             Stack[StackPtr].ElementType = esScalar;
  2616.                             ProgramCounter += 1;
  2617.                             break;
  2618.                         case epLoadImmediateDouble:
  2619.                             /*    -1        0   */
  2620.                             /* <opcode> <integer>; also used for boolean & fixed */
  2621.                             StackPtr += 1;
  2622.                             if (StackPtr >= StackSize)
  2623.                                 {
  2624.                                     StackElement*            NewStack;
  2625.  
  2626.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2627.                                         * sizeof(StackElement));
  2628.                                     if (NewStack == NIL)
  2629.                                         {
  2630.                                             StackPtr -= 1;
  2631.                                             ErrorCode = eEvalOutOfMemory;
  2632.                                             goto ExceptionPoint;
  2633.                                         }
  2634.                                     Stack = NewStack;
  2635.                                     StackSize += 8;
  2636.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2637.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  2638.                                 }
  2639.                             PRNGCHK(CurrentProcedure,
  2640.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateDouble),
  2641.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateDouble));
  2642.                             PRNGCHK(CurrentProcedure[ProgramCounter + 0].ImmediateDouble,
  2643.                                 &(*(CurrentProcedure[ProgramCounter + 0].ImmediateDouble)),
  2644.                                 sizeof(double));
  2645.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2646.                             Stack[StackPtr].Data.Double
  2647.                                 = *(CurrentProcedure[ProgramCounter + 0].ImmediateDouble);
  2648.                             Stack[StackPtr].ElementType = esScalar;
  2649.                             ProgramCounter += 1;
  2650.                             break;
  2651.                         case epLoadImmediateNILArray:
  2652.                             /* <opcode> */
  2653.                             StackPtr += 1;
  2654.                             if (StackPtr >= StackSize)
  2655.                                 {
  2656.                                     StackElement*            NewStack;
  2657.  
  2658.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2659.                                         * sizeof(StackElement));
  2660.                                     if (NewStack == NIL)
  2661.                                         {
  2662.                                             StackPtr -= 1;
  2663.                                             ErrorCode = eEvalOutOfMemory;
  2664.                                             goto ExceptionPoint;
  2665.                                         }
  2666.                                     Stack = NewStack;
  2667.                                     StackSize += 8;
  2668.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2669.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  2670.                                 }
  2671.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2672.                             Stack[StackPtr].Data.ArrayHandle = NIL;
  2673.                             Stack[StackPtr].ElementType = esArray;
  2674.                             break;
  2675.  
  2676.                         case epGetSampleLeftArray:
  2677.                             /*    -1           0    */
  2678.                             /* <opcode> ^"<namestring>" */
  2679.                             StackPtr += 1;
  2680.                             if (StackPtr >= StackSize)
  2681.                                 {
  2682.                                     StackElement*            NewStack;
  2683.  
  2684.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2685.                                         * sizeof(StackElement));
  2686.                                     if (NewStack == NIL)
  2687.                                         {
  2688.                                             StackPtr -= 1;
  2689.                                             ErrorCode = eEvalOutOfMemory;
  2690.                                             goto ExceptionPoint;
  2691.                                         }
  2692.                                     Stack = NewStack;
  2693.                                     StackSize += 8;
  2694.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2695.                                         PRERR(ForceAbort,"EvaluatePcode [epGetSampleLeftArray]: stack size inconsistency"));
  2696.                                 }
  2697.                             Stack[StackPtr].ElementType = esScalar;
  2698.                             PRNGCHK(CurrentProcedure,
  2699.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2700.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2701.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2702.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2703.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2704.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2705.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2706.                                 {
  2707.                                     ErrorCode = eEvalOutOfMemory;
  2708.                                     goto ExceptionPoint;
  2709.                                 }
  2710.                             switch ((*GetSampleLeftCopy)(Refcon,CurrentProcedure[
  2711.                                 ProgramCounter + 0].ImmediateString,
  2712.                                 (largefixedsigned**)&(Stack[StackPtr].Data.ArrayHandle->Array)))
  2713.                                 {
  2714.                                     case eEvalSampleNoError:
  2715.                                         CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  2716.                                         Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2717.                                         Stack[StackPtr].ElementType = esArray;
  2718.                                         break;
  2719.                                     case eEvalSampleUndefined:
  2720.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2721.                                         ErrorCode = eEvalGetSampleNotDefined;
  2722.                                         goto ExceptionPoint;
  2723.                                     case eEvalSampleWrongChannel:
  2724.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2725.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2726.                                         goto ExceptionPoint;
  2727.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2728.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2729.                                         ErrorCode = eEvalOutOfMemory;
  2730.                                         goto ExceptionPoint;
  2731.                                     default:
  2732.                                         EXECUTE(PRERR(ForceAbort,
  2733.                                             "EvaluatePcode [epGetSampleLeftArray]: unknown return code"));
  2734.                                         break;
  2735.                                 }
  2736.                             ProgramCounter += 1;
  2737.                             break;
  2738.                         case epGetSampleRightArray:
  2739.                             /*    -1           0    */
  2740.                             /* <opcode> ^"<namestring>" */
  2741.                             StackPtr += 1;
  2742.                             if (StackPtr >= StackSize)
  2743.                                 {
  2744.                                     StackElement*            NewStack;
  2745.  
  2746.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2747.                                         * sizeof(StackElement));
  2748.                                     if (NewStack == NIL)
  2749.                                         {
  2750.                                             StackPtr -= 1;
  2751.                                             ErrorCode = eEvalOutOfMemory;
  2752.                                             goto ExceptionPoint;
  2753.                                         }
  2754.                                     Stack = NewStack;
  2755.                                     StackSize += 8;
  2756.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2757.                                         PRERR(ForceAbort,"EvaluatePcode [epGetSampleRightArray]: stack size inconsistency"));
  2758.                                 }
  2759.                             Stack[StackPtr].ElementType = esScalar;
  2760.                             PRNGCHK(CurrentProcedure,
  2761.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2762.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2763.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2764.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2765.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2766.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2767.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2768.                                 {
  2769.                                     ErrorCode = eEvalOutOfMemory;
  2770.                                     goto ExceptionPoint;
  2771.                                 }
  2772.                             switch ((*GetSampleRightCopy)(Refcon,CurrentProcedure[
  2773.                                 ProgramCounter + 0].ImmediateString,
  2774.                                 (largefixedsigned**)&(Stack[StackPtr].Data.ArrayHandle->Array)))
  2775.                                 {
  2776.                                     case eEvalSampleNoError:
  2777.                                         CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  2778.                                         Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2779.                                         Stack[StackPtr].ElementType = esArray;
  2780.                                         break;
  2781.                                     case eEvalSampleUndefined:
  2782.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2783.                                         ErrorCode = eEvalGetSampleNotDefined;
  2784.                                         goto ExceptionPoint;
  2785.                                     case eEvalSampleWrongChannel:
  2786.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2787.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2788.                                         goto ExceptionPoint;
  2789.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2790.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2791.                                         ErrorCode = eEvalOutOfMemory;
  2792.                                         goto ExceptionPoint;
  2793.                                     default:
  2794.                                         EXECUTE(PRERR(ForceAbort,
  2795.                                             "EvaluatePcode [epGetSampleRightArray]: unknown return code"));
  2796.                                         break;
  2797.                                 }
  2798.                             ProgramCounter += 1;
  2799.                             break;
  2800.                         case epGetSampleMonoArray:
  2801.                             /*    -1           0    */
  2802.                             /* <opcode> ^"<namestring>" */
  2803.                             StackPtr += 1;
  2804.                             if (StackPtr >= StackSize)
  2805.                                 {
  2806.                                     StackElement*            NewStack;
  2807.  
  2808.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2809.                                         * sizeof(StackElement));
  2810.                                     if (NewStack == NIL)
  2811.                                         {
  2812.                                             StackPtr -= 1;
  2813.                                             ErrorCode = eEvalOutOfMemory;
  2814.                                             goto ExceptionPoint;
  2815.                                         }
  2816.                                     Stack = NewStack;
  2817.                                     StackSize += 8;
  2818.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2819.                                         PRERR(ForceAbort,"EvaluatePcode [epGetSampleMonoArray]: stack size inconsistency"));
  2820.                                 }
  2821.                             Stack[StackPtr].ElementType = esScalar;
  2822.                             PRNGCHK(CurrentProcedure,
  2823.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2824.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2825.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2826.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2827.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2828.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2829.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2830.                                 {
  2831.                                     ErrorCode = eEvalOutOfMemory;
  2832.                                     goto ExceptionPoint;
  2833.                                 }
  2834.                             switch ((*GetSampleMiddleCopy)(Refcon,CurrentProcedure[
  2835.                                 ProgramCounter + 0].ImmediateString,
  2836.                                 (largefixedsigned**)&(Stack[StackPtr].Data.ArrayHandle->Array)))
  2837.                                 {
  2838.                                     case eEvalSampleNoError:
  2839.                                         CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  2840.                                         Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2841.                                         Stack[StackPtr].ElementType = esArray;
  2842.                                         break;
  2843.                                     case eEvalSampleUndefined:
  2844.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2845.                                         ErrorCode = eEvalGetSampleNotDefined;
  2846.                                         goto ExceptionPoint;
  2847.                                     case eEvalSampleWrongChannel:
  2848.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2849.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2850.                                         goto ExceptionPoint;
  2851.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2852.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2853.                                         ErrorCode = eEvalOutOfMemory;
  2854.                                         goto ExceptionPoint;
  2855.                                     default:
  2856.                                         EXECUTE(PRERR(ForceAbort,
  2857.                                             "EvaluatePcode [epGetSampleMonoArray]: unknown return code"));
  2858.                                         break;
  2859.                                 }
  2860.                             ProgramCounter += 1;
  2861.                             break;
  2862.                         case epGetWaveTableArray:
  2863.                             /*    -1           0    */
  2864.                             /* <opcode> ^"<namestring>" */
  2865.                             StackPtr += 1;
  2866.                             if (StackPtr >= StackSize)
  2867.                                 {
  2868.                                     StackElement*            NewStack;
  2869.  
  2870.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2871.                                         * sizeof(StackElement));
  2872.                                     if (NewStack == NIL)
  2873.                                         {
  2874.                                             StackPtr -= 1;
  2875.                                             ErrorCode = eEvalOutOfMemory;
  2876.                                             goto ExceptionPoint;
  2877.                                         }
  2878.                                     Stack = NewStack;
  2879.                                     StackSize += 8;
  2880.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2881.                                         PRERR(ForceAbort,"EvaluatePcode [epGetWaveTableArray]: stack size inconsistency"));
  2882.                                 }
  2883.                             Stack[StackPtr].ElementType = esScalar;
  2884.                             PRNGCHK(CurrentProcedure,
  2885.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2886.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2887.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2888.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2889.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2890.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2891.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2892.                                 {
  2893.                                     ErrorCode = eEvalOutOfMemory;
  2894.                                     goto ExceptionPoint;
  2895.                                 }
  2896.                             switch ((*GetWaveTableCopy)(Refcon,CurrentProcedure[
  2897.                                 ProgramCounter + 0].ImmediateString,
  2898.                                 (largefixedsigned**)&(Stack[StackPtr].Data.ArrayHandle->Array)))
  2899.                                 {
  2900.                                     case eEvalSampleNoError:
  2901.                                         CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  2902.                                         Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2903.                                         Stack[StackPtr].ElementType = esArray;
  2904.                                         break;
  2905.                                     case eEvalSampleUndefined:
  2906.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2907.                                         ErrorCode = eEvalGetSampleNotDefined;
  2908.                                         goto ExceptionPoint;
  2909.                                     case eEvalSampleWrongChannel:
  2910.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2911.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2912.                                         goto ExceptionPoint;
  2913.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2914.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2915.                                         ErrorCode = eEvalOutOfMemory;
  2916.                                         goto ExceptionPoint;
  2917.                                     default:
  2918.                                         EXECUTE(PRERR(ForceAbort,
  2919.                                             "EvaluatePcode [epGetWaveTableArray]: unknown return code"));
  2920.                                         break;
  2921.                                 }
  2922.                             ProgramCounter += 1;
  2923.                             break;
  2924.                         case epGetWaveTableFrames:
  2925.                             /*    -1           0    */
  2926.                             /* <opcode> ^"<namestring>" */
  2927.                             StackPtr += 1;
  2928.                             if (StackPtr >= StackSize)
  2929.                                 {
  2930.                                     StackElement*            NewStack;
  2931.  
  2932.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2933.                                         * sizeof(StackElement));
  2934.                                     if (NewStack == NIL)
  2935.                                         {
  2936.                                             StackPtr -= 1;
  2937.                                             ErrorCode = eEvalOutOfMemory;
  2938.                                             goto ExceptionPoint;
  2939.                                         }
  2940.                                     Stack = NewStack;
  2941.                                     StackSize += 8;
  2942.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2943.                                         PRERR(ForceAbort,"EvaluatePcode [epGetWaveTableFrames]: stack size inconsistency"));
  2944.                                 }
  2945.                             Stack[StackPtr].ElementType = esScalar;
  2946.                             PRNGCHK(CurrentProcedure,
  2947.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2948.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2949.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2950.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2951.                             switch ((*GetWaveTableFrameCount)(Refcon,CurrentProcedure[
  2952.                                 ProgramCounter + 0].ImmediateString,&(Stack[StackPtr].Data.Integer)))
  2953.                                 {
  2954.                                     case eEvalSampleNoError:
  2955.                                         break;
  2956.                                     case eEvalSampleUndefined:
  2957.                                         ErrorCode = eEvalGetSampleNotDefined;
  2958.                                         goto ExceptionPoint;
  2959.                                     case eEvalSampleWrongChannel:
  2960.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2961.                                         goto ExceptionPoint;
  2962.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2963.                                         ErrorCode = eEvalOutOfMemory;
  2964.                                         goto ExceptionPoint;
  2965.                                     default:
  2966.                                         EXECUTE(PRERR(ForceAbort,
  2967.                                             "EvaluatePcode [epGetWaveTableFrames]: unknown return code"));
  2968.                                         break;
  2969.                                 }
  2970.                             ProgramCounter += 1;
  2971.                             break;
  2972.                         case epGetWaveTableTables:
  2973.                             /*    -1           0    */
  2974.                             /* <opcode> ^"<namestring>" */
  2975.                             StackPtr += 1;
  2976.                             if (StackPtr >= StackSize)
  2977.                                 {
  2978.                                     StackElement*            NewStack;
  2979.  
  2980.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2981.                                         * sizeof(StackElement));
  2982.                                     if (NewStack == NIL)
  2983.                                         {
  2984.                                             StackPtr -= 1;
  2985.                                             ErrorCode = eEvalOutOfMemory;
  2986.                                             goto ExceptionPoint;
  2987.                                         }
  2988.                                     Stack = NewStack;
  2989.                                     StackSize += 8;
  2990.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2991.                                         PRERR(ForceAbort,"EvaluatePcode [epGetWaveTableTables]: stack size inconsistency"));
  2992.                                 }
  2993.                             Stack[StackPtr].ElementType = esScalar;
  2994.                             PRNGCHK(CurrentProcedure,
  2995.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2996.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2997.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2998.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2999.                             switch ((*GetWaveTableTableCount)(Refcon,CurrentProcedure[
  3000.                                 ProgramCounter + 0].ImmediateString,&(Stack[StackPtr].Data.Integer)))
  3001.                                 {
  3002.                                     case eEvalSampleNoError:
  3003.                                         break;
  3004.                                     case eEvalSampleUndefined:
  3005.                                         ErrorCode = eEvalGetSampleNotDefined;
  3006.                                         goto ExceptionPoint;
  3007.                                     case eEvalSampleWrongChannel:
  3008.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  3009.                                         goto ExceptionPoint;
  3010.                                     case eEvalSampleNotEnoughMemoryToCopy:
  3011.                                         ErrorCode = eEvalOutOfMemory;
  3012.                                         goto ExceptionPoint;
  3013.                                     default:
  3014.                                         EXECUTE(PRERR(ForceAbort,
  3015.                                             "EvaluatePcode [epGetWaveTableTables]: unknown return code"));
  3016.                                         break;
  3017.                                 }
  3018.                             ProgramCounter += 1;
  3019.                             break;
  3020.  
  3021.                     } /* end switch */
  3022.             } /* end while */
  3023.  
  3024.  
  3025.         /* when something bad happens, set the ErrorCode with the error code and */
  3026.         /* jump here.  this will release all allocated arrays on the stack and in */
  3027.         /* the registers, set the offending function pcode, and return */
  3028.      ExceptionPoint:
  3029.         /* first, release all objects */
  3030.         while (StackPtr != GetStackNumElements(Prep) - 1)
  3031.             {
  3032.                 /* pop all elements except those that were there originally */
  3033.                 if ((Stack[StackPtr].ElementType == esArray)
  3034.                     && (Stack[StackPtr].Data.ArrayHandle != NIL))
  3035.                     {
  3036.                         DisposeIfNotOnStack(Stack,StackPtr);
  3037.                     }
  3038.                 StackPtr -= 1;
  3039.             }
  3040.         /* then set up the error values */
  3041.         *OffendingPcode = CurrentProcedure;
  3042.         *OffendingInstruction = ProgramCounter - 1;
  3043.         /* write back values that might have changed */
  3044.         SetStackInformation(Prep,StackSize,StackPtr + 1,Stack);
  3045.         return ErrorCode;
  3046.  
  3047.  
  3048.         /* when execution finishes, jump here.  The lowest element [0] in the stack will */
  3049.         /* have the return value, placed there according to calling conventions */
  3050.      TotallyDonePoint:
  3051.         /* check stack pointer */
  3052.         ERROR(StackPtr != GetStackNumElements(Prep) - 1,PRERR(ForceAbort,
  3053.             "EvaluatePcode:  normal exit, but final stack pointer != initial stack pointer"));
  3054.         /* write back values that might have changed */
  3055.         SetStackInformation(Prep,StackSize,StackPtr + 1,Stack);
  3056.         /* return message that indicates everything went fine */
  3057.         return eEvalNoError;
  3058.     }
  3059.  
  3060.  
  3061. char*                            GetPcodeErrorMessage(EvalErrors Error)
  3062.     {
  3063.         char*                        ErrorString;
  3064.  
  3065.         switch (Error)
  3066.             {
  3067.                 default:
  3068.                     EXECUTE(PRERR(ForceAbort,"GetPcodeErrorMessage:  unknown error code"));
  3069.                     break;
  3070.                 case eEvalUndefinedFunction:
  3071.                     ErrorString = "Called an undefined function.";
  3072.                     break;
  3073.                 case eEvalErrorTrapEncountered:
  3074.                     ErrorString = "Error trap encountered; user cancelled execution.";
  3075.                     break;
  3076.                 case eEvalUserCancelled:
  3077.                     ErrorString = "User cancelled.";
  3078.                     break;
  3079.                 case eEvalDivideByZero:
  3080.                     ErrorString = "Divide by zero.";
  3081.                     break;
  3082.                 case eEvalOutOfMemory:
  3083.                     ErrorString = "Out of memory.";
  3084.                     break;
  3085.                 case eEvalArrayDoesntExist:
  3086.                     ErrorString = "Use of unallocated (NIL) array.";
  3087.                     break;
  3088.                 case eEvalArraySubscriptOutOfRange:
  3089.                     ErrorString = "Array subscript out of range.";
  3090.                     break;
  3091.                 case eEvalGetSampleNotDefined:
  3092.                     ErrorString = "Attempt to access undefined sample or wave table.";
  3093.                     break;
  3094.                 case eEvalGetSampleWrongChannelType:
  3095.                     ErrorString = "Attempt to load sample array with wrong channel type.";
  3096.                     break;
  3097.                 case eEvalWrongNumParametersForFunction:
  3098.                     ErrorString = "Wrong number of parameters for function call.";
  3099.                     break;
  3100.                 case eEvalWrongParameterType:
  3101.                     ErrorString = "Parameter for function call does not match function's type.";
  3102.                     break;
  3103.                 case eEvalWrongReturnType:
  3104.                     ErrorString = "Return type for function call does not match function's type.";
  3105.                     break;
  3106.             }
  3107.         return ErrorString;
  3108.     }
  3109.